winreg

type BaseRegCloseKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
}

type BaseRegCloseKeyResponse struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// Return: The BaseRegCloseKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegCreateKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: BaseRegCreateKey, OpenClassesRoot,
	// OpenCurrentUser, OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that specifies the name of
	// the key (as specified in section 3.1.1.1) that this method opens or creates. The
	// name of the key specified is relative to the key specified by the hkey parameter.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
	// lpClass: A pointer to an RRP_UNICODE_STRING structure that specifies the class of
	// the key (as specified in section 3.1.1.6).<16>
	Class *UnicodeString `idl:"name:lpClass" json:"class"`
	// dwOptions: Registry key options. MUST be the bitwise OR of one of the key types defined
	// in section 3.1.1.2, and any or none of the following options. The BaseRegCreateKey
	// method fails with ERROR_INVALID_PARAMETER if an unlisted value is specified.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                                       |                                                                                  |
	//	|                *VALUE*                |                                    *MEANING*                                     |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_OPTION_BACKUP_RESTORE 0x00000004  | Indicates that the caller wishes to assert its backup and/or restore privileges. |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_OPTION_OPEN_LINK 0x00000008       | Indicates that the caller wishes to open the targeted symlink source rather than |
	//	|                                       | the symlink target.                                                              |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_OPTION_DONT_VIRTUALIZE 0x00000010 | Indicates that the caller wishes to disable limited user access virtualization   |
	//	|                                       | for this operation.                                                              |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	Options uint32 `idl:"name:dwOptions" json:"options"`
	// samDesired: A bit field that describes the wanted security access for the handle
	// to the key that is being created or opened. It MUST be constructed from one or more
	// of the values that are specified in section 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
	// lpSecurityAttributes: A pointer to an RPC_SECURITY_ATTRIBUTES structure for the new
	// subkey provided a new subkey is created.
	SecurityAttributes *SecurityAttributes `idl:"name:lpSecurityAttributes;pointer:unique" json:"security_attributes"`
	// lpdwDisposition: The disposition of the returned key indicated by phkResult. The
	// value of this parameter set by the client is ignored by the server. Its value MUST
	// be one of the following.
	//
	//	+------------------------------------+---------------------------------------------------------------+
	//	|                                    |                                                               |
	//	|               VALUE                |                            MEANING                            |
	//	|                                    |                                                               |
	//	+------------------------------------+---------------------------------------------------------------+
	//	+------------------------------------+---------------------------------------------------------------+
	//	| REG_CREATED_NEW_KEY 0x00000001     | The key did not exist and was created.                        |
	//	+------------------------------------+---------------------------------------------------------------+
	//	| REG_OPENED_EXISTING_KEY 0x00000002 | The key already existed and was opened without being changed. |
	//	+------------------------------------+---------------------------------------------------------------+
	Disposition uint32 `idl:"name:lpdwDisposition;pointer:unique" json:"disposition"`
}

type BaseRegCreateKeyResponse struct {
	// phkResult: A pointer to a variable that receives a handle to the opened or created
	// key.
	ResultKey *Key `idl:"name:phkResult" json:"result_key"`
	// lpdwDisposition: The disposition of the returned key indicated by phkResult. The
	// value of this parameter set by the client is ignored by the server. Its value MUST
	// be one of the following.
	//
	//	+------------------------------------+---------------------------------------------------------------+
	//	|                                    |                                                               |
	//	|               VALUE                |                            MEANING                            |
	//	|                                    |                                                               |
	//	+------------------------------------+---------------------------------------------------------------+
	//	+------------------------------------+---------------------------------------------------------------+
	//	| REG_CREATED_NEW_KEY 0x00000001     | The key did not exist and was created.                        |
	//	+------------------------------------+---------------------------------------------------------------+
	//	| REG_OPENED_EXISTING_KEY 0x00000002 | The key already existed and was opened without being changed. |
	//	+------------------------------------+---------------------------------------------------------------+
	Disposition uint32 `idl:"name:lpdwDisposition;pointer:unique" json:"disposition"`
	// Return: The BaseRegCreateKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegDeleteKeyExRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that MUST specify the name
	// of the key (as specified in section 3.1.1) to delete.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
	// AccessMask: A bit field that describes the wanted security access for the key.
	//
	//	+----------------------------+--------------------------------------------------------+
	//	|                            |                                                        |
	//	|           VALUE            |                        MEANING                         |
	//	|                            |                                                        |
	//	+----------------------------+--------------------------------------------------------+
	//	+----------------------------+--------------------------------------------------------+
	//	| KEY_WOW64_64KEY 0x00000100 | Explicitly delete the key in the 64-bit key namespace. |
	//	+----------------------------+--------------------------------------------------------+
	//	| KEY_WOW64_32KEY 0x00000200 | Explicitly delete the key in the 32-bit key namespace. |
	//	+----------------------------+--------------------------------------------------------+
	AccessMask uint32 `idl:"name:AccessMask" json:"access_mask"`
}

type BaseRegDeleteKeyExResponse struct {
	// Return: The BaseRegDeleteKeyEx return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegDeleteKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that MUST contain the name
	// of the key (as specified in section 3.1.1) to delete.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
}

type BaseRegDeleteKeyResponse struct {
	// Return: The BaseRegDeleteKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegDeleteValueRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpValueName: A pointer to an RRP_UNICODE_STRING structure that MUST contain the name
	// of the value (as specified in section 3.1.1) to remove. If the client sets the lpValueName
	// parameter to NULL, the server SHOULD<18> fail this method and return ERROR_INVALID_PARAMETER.
	ValueName *UnicodeString `idl:"name:lpValueName" json:"value_name"`
}

type BaseRegDeleteValueResponse struct {
	// Return: The BaseRegDeleteValue return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegEnumKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// dwIndex: The index of the subkey to retrieve, as specified in section 3.1.1.1.
	Index uint32 `idl:"name:dwIndex" json:"index"`
	// lpNameIn: A pointer to an RRP_UNICODE_STRING structure (section 2.2.4) that contains
	// the key name to be retrieved, as specified in section 3.1.1.1. This is used by the
	// server to determine the maximum length for the output name parameter and to allocate
	// space accordingly. The content is ignored, and only the maximum length is significant.
	// The Length field MUST be set to 0.
	NameIn *UnicodeString `idl:"name:lpNameIn" json:"name_in"`
	// lpClassIn: A pointer to an RRP_UNICODE_STRING structure (section 2.2.4) that contains
	// the class to be retrieved, as specified in section 3.1.1.6. This is used by the server
	// to determine the maximum length for the output class parameter and to allocate space
	// accordingly. The content is ignored.
	ClassIn *UnicodeString `idl:"name:lpClassIn;pointer:unique" json:"class_in"`
	// lpftLastWriteTime: MUST be the time when the value was last written (set or created).
	LastWriteTime *dtyp.Filetime `idl:"name:lpftLastWriteTime;pointer:unique" json:"last_write_time"`
}

type BaseRegEnumKeyResponse struct {
	// lpNameOut: A pointer to an RRP_UNICODE_STRING structure that receives the name of
	// the retrieved key, as specified in section 3.1.1.1. All fields MUST be set to 0.
	NameOut *UnicodeString `idl:"name:lpNameOut" json:"name_out"`
	// lplpClassOut: A pointer to a PRPC_UNICODE_STRING structure ([MS-DTYP] section 2.3.10),
	// that receives the class of the retrieved key, as specified in section 3.1.1.6. This
	// parameter is optional.
	ClassOut *dtyp.UnicodeString `idl:"name:lplpClassOut" json:"class_out"`
	// lpftLastWriteTime: MUST be the time when the value was last written (set or created).
	LastWriteTime *dtyp.Filetime `idl:"name:lpftLastWriteTime;pointer:unique" json:"last_write_time"`
	// Return: The BaseRegEnumKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegEnumValueRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// dwIndex: MUST be the index of the value to be retrieved, as specified in section
	// 3.1.1.5.
	Index uint32 `idl:"name:dwIndex" json:"index"`
	// lpValueNameIn: A pointer to an RRP_UNICODE_STRING structure that contains the value
	// name to be retrieved, as specified in section 3.1.1.5. This is used by the server
	// to determine the maximum length for the output name parameter and to allocate space
	// accordingly. The content is ignored, and only the maximum length is significant.
	ValueNameIn *UnicodeString `idl:"name:lpValueNameIn" json:"value_name_in"`
	// lpType: An optional pointer to a buffer that receives the REG_VALUE_TYPE of the value
	// (as specified in section 3.1.1.5), or it MUST be NULL.
	Type uint32 `idl:"name:lpType;pointer:unique" json:"type"`
	// lpData: An optional pointer to a buffer that receives the data of the value entry.
	Data []byte `idl:"name:lpData;size_is:(lpcbData);length_is:(lpcbLen);pointer:unique" json:"data"`
	// lpcbData: A pointer to a variable that MUST contain the size of the buffer that is
	// pointed to by lpData. MUST NOT be NULL if lpData is present.
	DataLength uint32 `idl:"name:lpcbData;pointer:unique" json:"data_length"`
	// lpcbLen: MUST specify the number of bytes to transmit to the client.
	Length uint32 `idl:"name:lpcbLen;pointer:unique" json:"length"`
}

type BaseRegEnumValueResponse struct {
	// lpValueNameOut: A pointer to an RPC_UNICODE_STRING structure that receives the retrieved
	// value name, as specified in section 3.1.1.5.
	ValueNameOut *dtyp.UnicodeString `idl:"name:lpValueNameOut" json:"value_name_out"`
	// lpType: An optional pointer to a buffer that receives the REG_VALUE_TYPE of the value
	// (as specified in section 3.1.1.5), or it MUST be NULL.
	Type uint32 `idl:"name:lpType;pointer:unique" json:"type"`
	// lpData: An optional pointer to a buffer that receives the data of the value entry.
	Data []byte `idl:"name:lpData;size_is:(lpcbData);length_is:(lpcbLen);pointer:unique" json:"data"`
	// lpcbData: A pointer to a variable that MUST contain the size of the buffer that is
	// pointed to by lpData. MUST NOT be NULL if lpData is present.
	DataLength uint32 `idl:"name:lpcbData;pointer:unique" json:"data_length"`
	// lpcbLen: MUST specify the number of bytes to transmit to the client.
	Length uint32 `idl:"name:lpcbLen;pointer:unique" json:"length"`
	// Return: The BaseRegEnumValue return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegFlushKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
}

type BaseRegFlushKeyResponse struct {
	// Return: The BaseRegFlushKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegGetKeySecurityRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// SecurityInformation: The information that is needed to determine the type of security
	// that is returned in pRpcSecurityDescriptorOut. See SECURITY_INFORMATION (includes
	// a list of possible values).
	SecurityInformation uint32 `idl:"name:SecurityInformation" json:"security_information"`
	// pRpcSecurityDescriptorIn: A pointer to a buffer containing a security descriptor.
	// The client MUST provide a pointer to an RPC_SECURITY_DESCRIPTOR with arbitrary contents.
	// The server uses the size of this security descriptor to validate the client has the
	// correct amount of memory allocated for the RPC_SECURITY_DESCRIPTOR pointed to by
	// the pRpcSecurityDescriptorOut parameter
	SecurityDescriptorIn *SecurityDescriptor `idl:"name:pRpcSecurityDescriptorIn" json:"security_descriptor_in"`
}

type BaseRegGetKeySecurityResponse struct {
	// pRpcSecurityDescriptorOut: A pointer to a buffer to which the requested security
	// descriptor MUST be written.
	SecurityDescriptorOut *SecurityDescriptor `idl:"name:pRpcSecurityDescriptorOut" json:"security_descriptor_out"`
	// Return: The BaseRegGetKeySecurity return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegGetVersionRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
}

type BaseRegGetVersionResponse struct {
	// lpdwVersion: A buffer in which the registry version MUST be returned. The registry
	// version is implementation-specific.<27>
	Version uint32 `idl:"name:lpdwVersion" json:"version"`
	// Return: The BaseRegGetVersion return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegLoadKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenUsers and OpenLocalMachine.
	//
	// Note  The other open methods in this protocol cannot be used to obtain the hKey parameter
	// because the server checks that the key specified by lpSubKey is a descendent of the
	// HKEY_LOCAL_MACHINE or HKEY_USERS root keys.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that specifies the name of
	// the key (as specified in section 3.1.1.1) that MUST be created under hKey.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
	// lpFile: A pointer to a null-terminated RRP_UNICODE_STRING structure that contains
	// the name of an existing registry file in which the specified key and subkeys are
	// to be saved. The format of the file name is implementation-specific. It is assumed
	// that this file was created with the BaseRegSaveKey method. If it does not exist,
	// the server creates a file with the specified name.
	File *UnicodeString `idl:"name:lpFile" json:"file"`
}

type BaseRegLoadKeyResponse struct {
	// Return: The BaseRegLoadKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegOpenKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegOpenKey, OpenCurrentConfig,
	// OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that MUST contain the name
	// of a key to open. This parameter is always relative to the key that is specified
	// by the hKey parameter and is a pointer to a null-terminated string that contains
	// the name of the subkey to open, as specified in section 3.1.1. This key MUST be an
	// existing subkey of the key that is identified by the hKey parameter.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
	// dwOptions: Registry key options. MUST be the bitwise OR of any or none of the following
	// values.
	//
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	|                                      |                                                                                  |
	//	|               *VALUE*                |                                    *MEANING*                                     |
	//	|                                      |                                                                                  |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_OPTION_BACKUP_RESTORE 0x00000004 | Indicates that the caller requests to assert its backup and/or restore           |
	//	|                                      | privileges.                                                                      |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_OPTION_OPEN_LINK 0x00000008      | Indicates that the caller requests to open the targeted symlink source rather    |
	//	|                                      | than the symlink target.                                                         |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	Options uint32 `idl:"name:dwOptions" json:"options"`
	// samDesired: A bit field that describes the requested security access for the handle
	// to the key that is being opened. It MUST be constructed from one or more of the values
	// that are specified in section 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type BaseRegOpenKeyResponse struct {
	// phkResult: A pointer to the handle of the open key. The server MUST return a NULL
	// for phkResult in case of failure.
	ResultKey *Key `idl:"name:phkResult" json:"result_key"`
	// Return: The BaseRegOpenKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegQueryInfoKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpClassIn: A pointer to an RRP_UNICODE_STRING structure that contains the class of
	// the key to be retrieved, as specified in section 3.1.1.6. This string is optional;
	// it is saved but is not used by the registry.
	ClassIn *UnicodeString `idl:"name:lpClassIn" json:"class_in"`
}

type BaseRegQueryInfoKeyResponse struct {
	// lpClassOut: A pointer to an RPC_UNICODE_STRING structure that receives the class
	// of this key, as specified in section 3.1.1.6.
	ClassOut *dtyp.UnicodeString `idl:"name:lpClassOut" json:"class_out"`
	// lpcSubKeys: A pointer to a DWORD that MUST receive the count of the subkeys of the
	// specified key.
	SubKeysCount uint32 `idl:"name:lpcSubKeys" json:"sub_keys_count"`
	// lpcbMaxSubKeyLen: A pointer to a DWORD that receives the size of the key's subkey
	// with the longest name, or a greater size, as the number of TCHAR elements.
	//
	// TCHAR elements are defined as follows.
	MaxSubKeyLength uint32 `idl:"name:lpcbMaxSubKeyLen" json:"max_sub_key_length"`
	// lpcbMaxClassLen: A pointer to a DWORD that receives the size of the longest string
	// that specifies a subkey class, or a greater size, in Unicode characters.
	MaxClassLength uint32 `idl:"name:lpcbMaxClassLen" json:"max_class_length"`
	// lpcValues: A pointer to a DWORD that receives the number of values that are associated
	// with the key.
	ValuesCount uint32 `idl:"name:lpcValues" json:"values_count"`
	// lpcbMaxValueNameLen: A pointer to a DWORD that receives the size of the key's longest
	// value name, or a greater size, as the number of TCHAR elements.
	MaxValueNameLength uint32 `idl:"name:lpcbMaxValueNameLen" json:"max_value_name_length"`
	// lpcbMaxValueLen: A pointer to a DWORD that receives the size in bytes of the longest
	// data component, or a greater size, in the key's values.
	MaxValueLength uint32 `idl:"name:lpcbMaxValueLen" json:"max_value_length"`
	// lpcbSecurityDescriptor: A pointer to a DWORD that receives the size in bytes of the
	// key's SECURITY_DESCRIPTOR.
	SecurityDescriptorLength uint32 `idl:"name:lpcbSecurityDescriptor" json:"security_descriptor_length"`
	// lpftLastWriteTime: A pointer to a FILETIME structure that receives the last write
	// time.
	LastWriteTime *dtyp.Filetime `idl:"name:lpftLastWriteTime" json:"last_write_time"`
	// Return: The BaseRegQueryInfoKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegQueryMultipleValues2Request struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText. The server SHOULD
	// NOT process requests on predefined keys.
	Key *Key `idl:"name:hKey" json:"key"`
	// val_listIn: A pointer to an array of RVALENT structures, one for each value to query.
	// The array holds the list of value names for which the type and data MUST be returned.
	ValueListIn []*ValueEntry `idl:"name:val_listIn;size_is:(num_vals);length_is:(num_vals)" json:"value_list_in"`
	// num_vals: The size as the number of RVALENT structures of the val_list array.
	ValsLength uint32 `idl:"name:num_vals" json:"vals_length"`
	// lpvalueBuf: The data for each value that is specified by the val_listOut parameter.
	Buffer []byte `idl:"name:lpvalueBuf;size_is:(ldwTotsize);length_is:(ldwTotsize);pointer:unique" json:"buffer"`
	// ldwTotsize: A value that indicates the size in bytes of lpvalueBuf.
	TotalSize uint32 `idl:"name:ldwTotsize" json:"total_size"`
}

type BaseRegQueryMultipleValues2Response struct {
	// val_listOut: A pointer to an array of RVALENT structures, one for each value to be
	// queried. This parameter is a placeholder to return the type, size, and data offset
	// for each requested value.
	ValueListOut []*ValueEntry `idl:"name:val_listOut;size_is:(num_vals);length_is:(num_vals)" json:"value_list_out"`
	// lpvalueBuf: The data for each value that is specified by the val_listOut parameter.
	Buffer []byte `idl:"name:lpvalueBuf;size_is:(ldwTotsize);length_is:(ldwTotsize);pointer:unique" json:"buffer"`
	// ldwRequiredSize: If lpvalueBuf is not large enough to contain all the data, this
	// parameter MUST return the size in bytes that is needed for lpvalueBuf to contain
	// all the required data.
	RequiredSize uint32 `idl:"name:ldwRequiredSize" json:"required_size"`
	// Return: The BaseRegQueryMultipleValues2 return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegQueryMultipleValuesRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// val_listIn: A pointer to an array of RVALENT structures, one for each value to be
	// queried. The array holds the list of value names for which the type and data MUST
	// be returned.
	ValueListIn []*ValueEntry `idl:"name:val_listIn;size_is:(num_vals);length_is:(num_vals)" json:"value_list_in"`
	// num_vals: The size in bytes of the val_list array.
	ValsLength uint32 `idl:"name:num_vals" json:"vals_length"`
	// lpvalueBuf: Returns the data for each value that is specified by the val_listOut
	// parameter.
	Buffer []byte `idl:"name:lpvalueBuf;size_is:(ldwTotsize);length_is:(ldwTotsize);pointer:unique" json:"buffer"`
	// ldwTotsize: The value that indicates the length in bytes of the lpvalueBuf parameter.
	TotalSize uint32 `idl:"name:ldwTotsize;pointer:ref" json:"total_size"`
}

type BaseRegQueryMultipleValuesResponse struct {
	// val_listOut: A pointer to an array of RVALENT structures, one for each value to be
	// queried.
	ValueListOut []*ValueEntry `idl:"name:val_listOut;size_is:(num_vals);length_is:(num_vals)" json:"value_list_out"`
	// lpvalueBuf: Returns the data for each value that is specified by the val_listOut
	// parameter.
	Buffer []byte `idl:"name:lpvalueBuf;size_is:(ldwTotsize);length_is:(ldwTotsize);pointer:unique" json:"buffer"`
	// ldwTotsize: The value that indicates the length in bytes of the lpvalueBuf parameter.
	TotalSize uint32 `idl:"name:ldwTotsize;pointer:ref" json:"total_size"`
	// Return: The BaseRegQueryMultipleValues return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegQueryValueRequest struct {
	// hKey: On input, a handle to a key that MUST have been opened previously by using
	// one of the open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpValueName: On input, the client sets lpValueName to a pointer to an RRP_UNICODE_STRING
	// structure that MUST contain the name of the value, as specified in section 3.1.1.
	// If the client sets lpValueName to NULL, the server MUST fail this method and return
	// ERROR_INVALID_PARAMETER.
	ValueName *UnicodeString `idl:"name:lpValueName" json:"value_name"`
	// lpType: On input, the client sets lpType to a pointer to a variable to receive the
	// type code of a value entry. On output, the server MUST set this parameter to NULL
	// if the value specified by the lpValueName parameter is not found. If the client sets
	// lpType to NULL, the server MUST fail this method and return ERROR_INVALID_PARAMETER.
	Type uint32 `idl:"name:lpType;pointer:unique" json:"type"`
	// lpData: On input, the client sets lpData to a pointer to a buffer to receive the
	// data of the value entry.
	Data []byte `idl:"name:lpData;size_is:(lpcbData);length_is:(lpcbLen);pointer:unique" json:"data"`
	// lpcbData: A pointer to a variable that, on input, contains the size in bytes of the
	// buffer that is pointed to by the lpData parameter. On output, the variable receives
	// the number of bytes that are returned in lpData. This length variable MUST be set
	// to 0 by the server if the client provides NULL for the lpData parameter.
	DataLength uint32 `idl:"name:lpcbData;pointer:unique" json:"data_length"`
	// lpcbLen: A pointer to a variable that contains the number of bytes to transmit to
	// the client. On input, the client MUST allocate the memory for this parameter and
	// the pointer value of this parameter MUST not be NULL. On output, the server MUST
	// set this parameter to the size (in bytes) of the buffer pointed to by the lpData
	// parameter. If the client sets lpcbLen to NULL, the server MUST fail this method and
	// return ERROR_INVALID_PARAMETER.
	Length uint32 `idl:"name:lpcbLen;pointer:unique" json:"length"`
}

type BaseRegQueryValueResponse struct {
	// lpType: On input, the client sets lpType to a pointer to a variable to receive the
	// type code of a value entry. On output, the server MUST set this parameter to NULL
	// if the value specified by the lpValueName parameter is not found. If the client sets
	// lpType to NULL, the server MUST fail this method and return ERROR_INVALID_PARAMETER.
	Type uint32 `idl:"name:lpType;pointer:unique" json:"type"`
	// lpData: On input, the client sets lpData to a pointer to a buffer to receive the
	// data of the value entry.
	Data []byte `idl:"name:lpData;size_is:(lpcbData);length_is:(lpcbLen);pointer:unique" json:"data"`
	// lpcbData: A pointer to a variable that, on input, contains the size in bytes of the
	// buffer that is pointed to by the lpData parameter. On output, the variable receives
	// the number of bytes that are returned in lpData. This length variable MUST be set
	// to 0 by the server if the client provides NULL for the lpData parameter.
	DataLength uint32 `idl:"name:lpcbData;pointer:unique" json:"data_length"`
	// lpcbLen: A pointer to a variable that contains the number of bytes to transmit to
	// the client. On input, the client MUST allocate the memory for this parameter and
	// the pointer value of this parameter MUST not be NULL. On output, the server MUST
	// set this parameter to the size (in bytes) of the buffer pointed to by the lpData
	// parameter. If the client sets lpcbLen to NULL, the server MUST fail this method and
	// return ERROR_INVALID_PARAMETER.
	Length uint32 `idl:"name:lpcbLen;pointer:unique" json:"length"`
	// Return: The BaseRegQueryValue return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegReplaceKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: A pointer to an RRP_UNICODE_STRING structure that MUST either contain the
	// name of the key whose subkeys and values are replaced by this method (as specified
	// in section 3.1.1), or be NULL.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
	// lpNewFile: A pointer to an RRP_UNICODE_STRING structure that MUST contain a registry
	// file name with the registration information, as specified in section 3.1.1. The format
	// of the file name is implementation-specific, but both lpNewFile and lpOldFile SHOULD<22>
	// be in the same format.
	NewFile *UnicodeString `idl:"name:lpNewFile" json:"new_file"`
	// lpOldFile: A pointer to an RRP_UNICODE_STRING structure that MUST contain the registry
	// file name that receives a backup copy of the replaced registry information. The format
	// of the file name is implementation-specific, but is in the same format as lpNewFile.
	OldFile *UnicodeString `idl:"name:lpOldFile" json:"old_file"`
}

type BaseRegReplaceKeyResponse struct {
	// Return: The BaseRegReplaceKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegRestoreKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpFile: A pointer to an RRP_UNICODE_STRING structure that contains an existing registry
	// file name. The format of the file name SHOULD<24> be implementation-specific.
	File *UnicodeString `idl:"name:lpFile" json:"file"`
	// Flags: An optional flag argument that is the bitwise OR of any of the following options.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|                                    |                                                                                  |
	//	|               VALUE                |                                     MEANING                                      |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_WHOLE_HIVE_VOLATILE 0x00000001 | If set, registry keys created in the Data Store from the file indicated by       |
	//	|                                    | lpFile MUST be VOLATILE.                                                         |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_REFRESH_HIVE 0x00000002        | If set, the location of the subtree that the hKey parameter points to is         |
	//	|                                    | restored to its state immediately following the last flush. The subtree MUST     |
	//	|                                    | NOT be lazy flushed (by calling BaseRegRestoreKey with REG_NO_LAZY_FLUSH         |
	//	|                                    | specified as the value of this parameter); the caller MUST be a member of the    |
	//	|                                    | Administrators Group; and the handle the hKey parameter refers to MUST point to  |
	//	|                                    | the root of the subtree.                                                         |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_NO_LAZY_FLUSH 0x00000004       | If set, the key or subtree that is specified by the hKey parameter does not      |
	//	|                                    | automatically flush at regular intervals of time. The server MUST set the        |
	//	|                                    | property KEYNOPERIODICFLUSH equal to TRUE for the key specified by the hKey      |
	//	|                                    | parameter and all subkeys (see section 3.1.1.3).                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| REG_FORCE_RESTORE 0x00000008       | If set, the restore operation is executed even if open handles exist at (or      |
	//	|                                    | beneath) the location in the registry hierarchy to which the hKey parameter      |
	//	|                                    | points.<25>                                                                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:Flags" json:"flags"`
}

type BaseRegRestoreKeyResponse struct {
	// Return: The BaseRegRestoreKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegSaveKeyExRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpFile: A pointer to an RRP_UNICODE_STRING structure that contains the name of the
	// file in which the specified key and subkeys are saved. The format of the file name
	// is implementation-specific.
	File *UnicodeString `idl:"name:lpFile" json:"file"`
	// pSecurityAttributes: A pointer to an RPC_SECURITY_ATTRIBUTES structure that specifies
	// a security descriptor for the new file. If the pSecurityAttributes parameter is NULL,
	// the file receives a default security descriptor.
	SecurityAttributes *SecurityAttributes `idl:"name:pSecurityAttributes;pointer:unique" json:"security_attributes"`
	// Flags: Specifies the format for the saved key. This MUST be one of the following
	// values.
	//
	//	+-------+-----------------------------------------------------+
	//	|       |                                                     |
	//	| VALUE |                       MEANING                       |
	//	|       |                                                     |
	//	+-------+-----------------------------------------------------+
	//	+-------+-----------------------------------------------------+
	//	|     1 | The key or subtree is saved in the original format. |
	//	+-------+-----------------------------------------------------+
	//	|     2 | The key or subtree is saved in the latest format.   |
	//	+-------+-----------------------------------------------------+
	//	|     4 | The key or subtree is saved without compression.    |
	//	+-------+-----------------------------------------------------+
	Flags uint32 `idl:"name:Flags" json:"flags"`
}

type BaseRegSaveKeyExResponse struct {
	// Return: The BaseRegSaveKeyEx return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegSaveKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpFile: A pointer to an RRP_UNICODE_STRING structure that contains the name of the
	// registry file in which the specified key and subkeys are to be saved. The format
	// of the file name SHOULD<26> be implementation-specific.
	File *UnicodeString `idl:"name:lpFile" json:"file"`
	// pSecurityAttributes: A pointer to an RPC_SECURITY_ATTRIBUTES structure.
	SecurityAttributes *SecurityAttributes `idl:"name:pSecurityAttributes;pointer:unique" json:"security_attributes"`
}

type BaseRegSaveKeyResponse struct {
	// Return: The BaseRegSaveKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegSetKeySecurityRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// SecurityInformation: The SECURITY_INFORMATION that specifies the content of the pRpcSecurityDescriptor
	// parameter.
	SecurityInformation uint32 `idl:"name:SecurityInformation" json:"security_information"`
	// pRpcSecurityDescriptor: A pointer to the RPC_SECURITY_DESCRIPTOR to set for the supplied
	// key.
	SecurityDescriptor *SecurityDescriptor `idl:"name:pRpcSecurityDescriptor" json:"security_descriptor"`
}

type BaseRegSetKeySecurityResponse struct {
	// Return: The BaseRegSetKeySecurity return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegSetValueRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenClassesRoot, OpenCurrentUser,
	// OpenLocalMachine, OpenPerformanceData, OpenUsers, BaseRegCreateKey, BaseRegOpenKey,
	// OpenCurrentConfig, OpenPerformanceText, OpenPerformanceNlsText.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpValueName: MUST be a pointer to an RRP_UNICODE_STRING structure that contains the
	// name of the value (as specified in section 3.1.1.5) to set.
	ValueName *UnicodeString `idl:"name:lpValueName" json:"value_name"`
	// dwType: The type of data to be stored. This MUST be one of the REG_VALUE_TYPE values
	// specified in section 3.1.1.5.
	Type uint32 `idl:"name:dwType" json:"type"`
	// lpData: A pointer to a buffer that contains the data to set for the value entry.
	Data []byte `idl:"name:lpData;size_is:(cbData)" json:"data"`
	// cbData: The length in bytes of the information to be stored.
	DataLength uint32 `idl:"name:cbData" json:"data_length"`
}

type BaseRegSetValueResponse struct {
	// Return: The BaseRegSetValue return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type BaseRegUnloadKeyRequest struct {
	// hKey: A handle to a key that MUST have been opened previously by using one of the
	// open methods that are specified in section 3.1.5: OpenCurrentUser and OpenLocalMachine.
	Key *Key `idl:"name:hKey" json:"key"`
	// lpSubKey: An optional pointer to an RRP_UNICODE_STRING structure that MUST contain
	// the relative name, as specified in section 3.1.1.1.2. The lpSubKey parameter points
	// to the name of the key that is to be unloaded.
	SubKey *UnicodeString `idl:"name:lpSubKey" json:"sub_key"`
}

type BaseRegUnloadKeyResponse struct {
	// Return: The BaseRegUnLoadKey return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type Key dcetypes.ContextHandle

type OpenClassesRootRequest struct {
	// ServerName: The server name. The ServerName SHOULD be sent as NULL, and MUST be ignored
	// when it is received because binding to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: A bit field that describes the requested security access for the key.
	// It MUST be constructed from one or more of the values specified in section 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenClassesRootResponse struct {
	// phKey: A pointer to an RPC context handle for the root key, HKEY_CLASSES_ROOT, as
	// specified in section 3.1.1.7. The handle is found in the handle table (HANDLETABLE).
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenClassesRoot return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenCurrentConfigRequest struct {
	// ServerName: This SHOULD be sent as NULL and MUST be ignored on receipt because the
	// binding to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: A bit field that describes the wanted security access for the key. It
	// MUST be constructed from one or more of the values that are specified in section
	// 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenCurrentConfigResponse struct {
	// phKey: A handle to the root key, HKEY_CURRENT_CONFIG, as specified in section 3.1.1.7.
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenCurrentConfig return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenCurrentUserRequest struct {
	// ServerName: SHOULD be sent as NULL, and MUST be ignored on receipt because the binding
	// to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: A bit field that describes the wanted security access for the key. It
	// MUST be constructed from one or more of the values that are specified in section
	// 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenCurrentUserResponse struct {
	// phKey: A pointer to an RPC context handle for the root key, HKEY_CURRENT_USER, as
	// specified in section 3.1.1.7. The handle is found in the handle table (HANDLETABLE).
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenCurrentUser return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenLocalMachineRequest struct {
	// ServerName: SHOULD be sent as NULL and MUST be ignored on receipt because the binding
	// to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: A bit field that describes the wanted security access for the key. It
	// MUST be constructed from one or more of the values that are specified in section
	// 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenLocalMachineResponse struct {
	// phKey: A pointer to an RPC context handle for the root key, HKEY_LOCAL_MACHINE, as
	// specified in section 3.1.1.7. The handle is found in the handle table (HANDLETABLE).
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenLocalMachine return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenPerformanceDataRequest struct {
	// ServerName: SHOULD be sent as NULL and MUST be ignored on receipt because the binding
	// to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: SHOULD be sent as 0 and MUST be ignored on receipt.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenPerformanceDataResponse struct {
	// phKey: A pointer to an RPC context handle for the root key, HKEY_PERFORMANCE_DATA,
	// as specified in section 3.1.1.7. The handle is found in the handle table (HANDLETABLE).
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenPerformanceData return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenPerformanceNlsTextRequest struct {
	// ServerName: This SHOULD be sent as NULL and MUST be ignored on receipt because the
	// binding to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: This SHOULD be sent as 0 and MUST be ignored on receipt.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenPerformanceNlsTextResponse struct {
	// phKey: A pointer to a variable that receives a handle to the root key HKEY_PERFORMANCE_NLSTEXT,
	// as specified in section 3.1.1.7.
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenPerformanceNlsText return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenPerformanceTextRequest struct {
	// ServerName: SHOULD be sent as NULL and MUST be ignored on receipt because the binding
	// to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: SHOULD be sent as 0 and MUST be ignored on receipt.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenPerformanceTextResponse struct {
	// phKey: A pointer to a variable that receives a handle to the root key HKEY_PERFORMANCE_TEXT.
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenPerformanceText return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type OpenUsersRequest struct {
	// ServerName: SHOULD be sent as NULL and MUST be ignored on receipt because the binding
	// to the server is already complete at this stage.
	ServerName string `idl:"name:ServerName;pointer:unique" json:"server_name"`
	// samDesired: The bit field that describes the wanted security access for the key.
	// It MUST be constructed from one or more of the values that are specified in section
	// 2.2.3.
	DesiredAccess uint32 `idl:"name:samDesired" json:"desired_access"`
}

type OpenUsersResponse struct {
	// phKey: A pointer to an RPC context handle for the root key, HKEY_USERS, as specified
	// in section 3.1.1.7. The handle is found in the handle table (HANDLETABLE).
	Key *Key `idl:"name:phKey" json:"key"`
	// Return: The OpenUsers return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

type SecurityAttributes struct {
	// nLength:  The length in bytes of the security descriptor.
	Length uint32 `idl:"name:nLength" json:"length"`
	// RpcSecurityDescriptor:  The security descriptor that MUST be as specified in RPC_SECURITY_DESCRIPTOR.
	SecurityDescriptor *SecurityDescriptor `idl:"name:RpcSecurityDescriptor" json:"security_descriptor"`
	// bInheritHandle:  TRUE if the new process inherits the handle; otherwise, FALSE.
	InheritHandle bool `idl:"name:bInheritHandle" json:"inherit_handle"`
}

type SecurityDescriptor struct {
	// lpSecurityDescriptor:  A buffer that contains a SECURITY_DESCRIPTOR, as specified
	// in [MS-DTYP] section 2.4.6.
	SecurityDescriptor []byte `` /* 127-byte string literal not displayed */
	// cbInSecurityDescriptor:  The size in bytes of the security descriptor.
	InSecurityDescriptorLength uint32 `idl:"name:cbInSecurityDescriptor" json:"in_security_descriptor_length"`
	// cbOutSecurityDescriptor:  The size in bytes of the security descriptor.
	OutSecurityDescriptorLength uint32 `idl:"name:cbOutSecurityDescriptor" json:"out_security_descriptor_length"`
}

type UnicodeString dtyp.UnicodeString

type ValueEntry struct {
	// ve_valuename:  A pointer to an RRP_UNICODE_STRING structure that MUST contain the
	// name of the specified value to be retrieved.
	ValueName *dtyp.UnicodeString `idl:"name:ve_valuename" json:"value_name"`
	// ve_valuelen:   The length in bytes of the ve_valueptr buffer.
	ValueLength uint32 `idl:"name:ve_valuelen" json:"value_length"`
	// ve_valueptr:  A pointer to the data that is associated with a specified value.
	ValuePointer uint32 `idl:"name:ve_valueptr" json:"value_pointer"`
	// ve_type:  The type of the data that is associated with a specified value. For additional
	// specification of the possible values, see section 3.1.1.5.
	//
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	|                            |                                                                                  |
	//	|           VALUE            |                                     MEANING                                      |
	//	|                            |                                                                                  |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_BINARY 3               | Binary data in any form.                                                         |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_DWORD 4                | A 32-bit number.                                                                 |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_DWORD_LITTLE_ENDIAN 4  | A 32-bit number in little-endian format.                                         |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_DWORD_BIG_ENDIAN 5     | A 32-bit number in big-endian format.                                            |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_EXPAND_SZ 2            | A null-terminated string that contains unexpanded references to environment      |
	//	|                            | variables (for example, "%PATH%"). It will be a Unicode or system code page      |
	//	|                            | string, depending on the functions used to manipulate the string.                |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_LINK 6                 | A symbolic link.                                                                 |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_MULTI_SZ 7             | A sequence of null-terminated strings, terminated by an empty string (\0).       |
	//	|                            | For example: String1\0String2\0String3\0LastString\0\0 The first \0 terminates   |
	//	|                            | the first string, the second to the last \0 terminates the last string, and      |
	//	|                            | the final \0 terminates the sequence. Note that the final terminator MUST be     |
	//	|                            | factored into the length of the string.                                          |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_NONE 0                 | No defined value type.                                                           |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_QWORD 11               | A 64-bit number.                                                                 |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_QWORD_LITTLE_ENDIAN 11 | A 64-bit number in little-endian format.                                         |
	//	+----------------------------+----------------------------------------------------------------------------------+
	//	| REG_SZ 1                   | A null-terminated string. This string is either a Unicode or an system code page |
	//	|                            | string, depending on the functions used to manipulate the string.                |
	//	+----------------------------+----------------------------------------------------------------------------------+
	Type uint32 `idl:"name:ve_type" json:"type"`
}

type WinregClient interface {

	// The OpenClassesRoot method is called by the client. In response, the server opens
	// the HKEY_CLASSES_ROOT  predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenClassesRoot(context.Context, *OpenClassesRootRequest, ...dcerpc.CallOption) (*OpenClassesRootResponse, error)

	// The OpenCurrentUser method is called by the client. In response, the server opens
	// a handle to the HKEY_CURRENT_USER key. The server MUST determine which subkey of
	// HKEY_USERS is the correct key to map to HKEY_CURRENT_USER, as explained in section
	// 3.1.1.8.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated (SHUTDOWNINPROGRESS is set to TRUE).                                   |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenCurrentUser(context.Context, *OpenCurrentUserRequest, ...dcerpc.CallOption) (*OpenCurrentUserResponse, error)

	// The OpenLocalMachine method is called by the client. In response, the server opens
	// a handle to the HKEY_LOCAL_MACHINE predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenLocalMachine(context.Context, *OpenLocalMachineRequest, ...dcerpc.CallOption) (*OpenLocalMachineResponse, error)

	// The OpenPerformanceData method is called by the client. In response, the server opens
	// a handle to the HKEY_PERFORMANCE_DATA predefined key. The HKEY_PERFORMANCE_DATA  predefined
	// key is used to retrieve performance information from a registry server using only
	// the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The server
	// SHOULD return without modification any other error code encountered in servicing
	// the client request.
	//
	// The most common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenPerformanceData(context.Context, *OpenPerformanceDataRequest, ...dcerpc.CallOption) (*OpenPerformanceDataResponse, error)

	// The OpenUsers method is called by the client. In response, the server opens a handle
	// to the HKEY_USERS predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The server
	// SHOULD return without modification any error code encountered in servicing the client
	// request.
	//
	// The most common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenUsers(context.Context, *OpenUsersRequest, ...dcerpc.CallOption) (*OpenUsersResponse, error)

	// The BaseRegCloseKey method is called by the client. In response, the server destroys
	// (closes) the handle to the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN              |                                                                                  |
	//	|           VALUE/CODE            |                                   DESCRIPTION                                    |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000006 ERROR_INVALID_HANDLE | The handle is invalid.                                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000AA ERROR_BUSY           | The requested resource is in use.                                                |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT  | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                 | server can no longer service registry requests because server shutdown has been  |
	//	|                                 | initiated.                                                                       |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000015 ERROR_NOT_READY      | The service is not read. Calls can be repeated at a later time.                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000102 WAIT_TIMEOUT         | The wait operation timed out.                                                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	BaseRegCloseKey(context.Context, *BaseRegCloseKeyRequest, ...dcerpc.CallOption) (*BaseRegCloseKeyResponse, error)

	// The BaseRegCreateKey method is called by the client. In response, the server creates
	// the specified registry key and returns a handle to the newly created key. If the
	// key already exists in the registry, a handle to the existing key is opened and returned.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_CREATE_SUB_KEY access rights.                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | Access is denied.                                                                |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegCreateKey(context.Context, *BaseRegCreateKeyRequest, ...dcerpc.CallOption) (*BaseRegCreateKeyResponse, error)

	// The BaseRegDeleteKey method is called by the client. In response, the server deletes
	// the specified subkey.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | Access is denied. For BaseRegDeleteKey, this error will be returned when the key |
	//	|                                    | indicated by the lpSubKey parameter has subkeys.                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteKey(context.Context, *BaseRegDeleteKeyRequest, ...dcerpc.CallOption) (*BaseRegDeleteKeyResponse, error)

	// The BaseRegDeleteValue method is called by the client. In response, the server removes
	// a named value from the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_SET_VALUE access rights.                            |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteValue(context.Context, *BaseRegDeleteValueRequest, ...dcerpc.CallOption) (*BaseRegDeleteValueResponse, error)

	// The BaseRegEnumKey method is called by the client in order to enumerate a subkey.
	// In response, the server returns a requested subkey.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_ENUMERATE_SUB_KEYS access rights.                   |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY       | Not enough storage is available to complete this operation.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000103 ERROR_NO_MORE_ITEMS     | No more data is available.                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The size of the buffer is not large enough to hold the requested data.           |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegEnumKey(context.Context, *BaseRegEnumKeyRequest, ...dcerpc.CallOption) (*BaseRegEnumKeyResponse, error)

	// The BaseRegEnumValue method is called by the client. In response, the server enumerates
	// the value at the specified index for the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2 The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                |                                                                                  |
	//	|              VALUE/CODE              |                                   DESCRIPTION                                    |
	//	|                                      |                                                                                  |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED       | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY         | Not enough storage is available to complete this operation.                      |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER   | A parameter is incorrect.                                                        |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000007A ERROR_INSUFFICIENT_BUFFER | The data area passed to a system call is too small.                              |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA           | More data is available.                                                          |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000103 ERROR_NO_MORE_ITEMS       | No more data is available.                                                       |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT       | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                      | server can no longer service registry requests because server shutdown has been  |
	//	|                                      | initiated.                                                                       |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	BaseRegEnumValue(context.Context, *BaseRegEnumValueRequest, ...dcerpc.CallOption) (*BaseRegEnumValueResponse, error)

	// The BaseRegFlushKey method is called by the client. In response, the server writes
	// all of the subkeys and values of the key indicated by the hKey parameter to the backing
	// store for registry data.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2.
	//
	//	+--------------------------------+---------------------------------------------------------+
	//	|             RETURN             |                                                         |
	//	|           VALUE/CODE           |                       DESCRIPTION                       |
	//	|                                |                                                         |
	//	+--------------------------------+---------------------------------------------------------+
	//	+--------------------------------+---------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | The caller does not have KEY_QUERY_VALUE access rights. |
	//	+--------------------------------+---------------------------------------------------------+
	BaseRegFlushKey(context.Context, *BaseRegFlushKeyRequest, ...dcerpc.CallOption) (*BaseRegFlushKeyResponse, error)

	// The BaseRegGetKeySecurity method is called by the client. In response, the server
	// returns a copy of the security descriptor that protects the specified open registry
	// key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY       | Not enough storage is available to complete this operation.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegGetKeySecurity(context.Context, *BaseRegGetKeySecurityRequest, ...dcerpc.CallOption) (*BaseRegGetKeySecurityResponse, error)

	// The BaseRegLoadKey method is called by the client. In response, the server loads
	// key, subkey, and value data from a file and inserts the data into the registry hierarchy.
	//
	// The BaseRegLoadKey method is designed for use in backup and recovery scenarios where
	// the client first loads a registry hive from a file on disk using the BaseRegLoadKey
	// method. Then, after reading or writing key data from the loaded hive, the client
	// uses the BaseRegUnLoadKey method to unload the hive. For example, a backup application
	// loads another user hive (another user's HKEY_CURRENT_USER ) from a file on disk using
	// the BaseRegLoadKey method. After reading key and value data, it will unload the hive
	// using the BaseRegUnLoadKey method.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000003F9 ERROR_NOT_REGISTRY_FILE | The system attempted to load or restore a file into the registry, but the        |
	//	|                                    | specified file is not in a registry file format.                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegLoadKey(context.Context, *BaseRegLoadKeyRequest, ...dcerpc.CallOption) (*BaseRegLoadKeyResponse, error)

	// The BaseRegOpenKey method is called by the client. In response, the server opens
	// a specified key for access and returns a handle to it.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2.
	BaseRegOpenKey(context.Context, *BaseRegOpenKeyRequest, ...dcerpc.CallOption) (*BaseRegOpenKeyResponse, error)

	// The BaseRegQueryInfoKey method is called by the client. In response, the server returns
	// relevant information on the key that corresponds to the specified key handle.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The size of the buffer is not large enough to hold the requested data.           |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryInfoKey(context.Context, *BaseRegQueryInfoKeyRequest, ...dcerpc.CallOption) (*BaseRegQueryInfoKeyResponse, error)

	// The BaseRegQueryValue method is called by the client. In response, the server returns
	// the data that is associated with the named value of a specified registry open key.
	// If a value name is not specified, the server returns the data that is associated
	// with the default value of the specified registry open key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000002 ERROR_FILE_NOT_FOUND    | The value specified by lpValueName was not found. If lpValueName was not         |
	//	|                                    | specified, the default value has not been defined.                               |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The data to be returned is larger than the buffer provided.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryValue(context.Context, *BaseRegQueryValueRequest, ...dcerpc.CallOption) (*BaseRegQueryValueResponse, error)

	// The BaseRegReplaceKey method is called by the client. In response, the server MUST
	// read the registry information from the specified file and replace the specified key
	// with the content of the file. When the system is started again, the key and subkeys
	// have the same values as those in the specified file.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000011 ERROR_NOT_SAME_DEVICE   | The file indicated by lpOldFile is not on the same physical volume as the file   |
	//	|                                    | indicated by lpNewFile.                                                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegReplaceKey(context.Context, *BaseRegReplaceKeyRequest, ...dcerpc.CallOption) (*BaseRegReplaceKeyResponse, error)

	// The BaseRegRestoreKey method is called by the client. In response, the server reads
	// the registry information in a specified file and copies it over the specified key.
	// The registry information takes the form of a key and multiple levels of subkeys.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegRestoreKey(context.Context, *BaseRegRestoreKeyRequest, ...dcerpc.CallOption) (*BaseRegRestoreKeyResponse, error)

	// The BaseRegSaveKey method is called by the client. In response, the server saves
	// the specified key, subkeys, and values to a new file.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in either [MS-ERREF] section 2.2 or
	// [MS-ERREF] section 2.3.1. The most common error codes are listed in the following
	// table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSaveKey(context.Context, *BaseRegSaveKeyRequest, ...dcerpc.CallOption) (*BaseRegSaveKeyResponse, error)

	// The BaseRegSetKeySecurity method is called by the client. In response, the server
	// sets the security descriptor that protects the specified open registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSetKeySecurity(context.Context, *BaseRegSetKeySecurityRequest, ...dcerpc.CallOption) (*BaseRegSetKeySecurityResponse, error)

	// The BaseRegSetValue method is called by the client. In response, the server sets
	// the data for the specified value of a registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_SET_VALUE access rights, or the value being set to  |
	//	|                                    | a symbolic key is not the literal string "SymbolicLinkValue".                    |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSetValue(context.Context, *BaseRegSetValueRequest, ...dcerpc.CallOption) (*BaseRegSetValueResponse, error)

	// The BaseRegUnLoadKey method is called by the client. In response, the server removes
	// the specified discrete body of keys, subkeys, and values that is rooted at the top
	// of the registry hierarchy.
	//
	// The BaseRegUnLoadKey method is designed for use in backup and recovery scenarios
	// where the client first loads a registry hive from a file on disk using the BaseRegLoadKey
	// method. Then, after reading or writing key data from the loaded hive, the client
	// uses the BaseRegUnLoadKey method to unload the hive. For example, a backup application
	// can load another user hive (another user's HKEY_CURRENT_USER) from a file on disk
	// using the BaseRegLoadKey method. Then, after reading key and value data, it will
	// unload the hive using the BaseRegUnLoadKey method.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000002 ERROR_FILE_NOT_FOUND    | The key specified by the handle hKey and the lpSubKey parameter does not exist   |
	//	|                                    | in the key namespace.                                                            |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The key specified by the handle hKey and the lpSubKey parameter is not a         |
	//	|                                    | descendent key of the HKEY_LOCAL_MACHINE or HKEY_USERS root keys, or there are   |
	//	|                                    | open handles to the key or its descendants.                                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegUnloadKey(context.Context, *BaseRegUnloadKeyRequest, ...dcerpc.CallOption) (*BaseRegUnloadKeyResponse, error)

	// The BaseRegGetVersion method is called by the client. In response, the server returns
	// the version of the remote registry server. The BaseRegGetVersion method is used by
	// the client and the server to determine if the remote registry server supports both
	// 32-bit and 64-bit key namespaces.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns the following nonzero error code.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000003E6 ERROR_NOACCESS      | Invalid access to memory location.                                               |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	BaseRegGetVersion(context.Context, *BaseRegGetVersionRequest, ...dcerpc.CallOption) (*BaseRegGetVersionResponse, error)

	// The OpenCurrentConfig method is called by the client. In response, the server attempts
	// to open a handle to the HKEY_CURRENT_CONFIG predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenCurrentConfig(context.Context, *OpenCurrentConfigRequest, ...dcerpc.CallOption) (*OpenCurrentConfigResponse, error)

	// The BaseRegQueryMultipleValues method is called by the client. In response, the server
	// returns the type and data for a client-specified list of value names that are associated
	// with the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED        | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER    | A parameter is incorrect.                                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000078 ERROR_CALL_NOT_IMPLEMENTED | This function is not supported on this system.                                   |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT        | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                       | server can no longer service registry requests because server shutdown has been  |
	//	|                                       | initiated.                                                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryMultipleValues(context.Context, *BaseRegQueryMultipleValuesRequest, ...dcerpc.CallOption) (*BaseRegQueryMultipleValuesResponse, error)

	// The BaseRegSaveKeyEx method is called by the client. In response, the server saves
	// the specified key, subkeys, and values to a new file. The BaseRegSaveKeyEx method
	// accepts flags that determine the format for the saved key or and values.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The server does not have access permissions to save the file at the specified    |
	//	|                                    | location.                                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000B7 ERROR_ALREADY_EXISTS    | Cannot create a file when that file already exists.                              |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSaveKeyEx(context.Context, *BaseRegSaveKeyExRequest, ...dcerpc.CallOption) (*BaseRegSaveKeyExResponse, error)

	// The OpenPerformanceText method is called by the client. In response, the server opens
	// a handle to the HKEY_PERFORMANCE_TEXT predefined key. The HKEY_PERFORMANCE_TEXT predefined
	// key is used to retrieve performance information from a registry server using only
	// the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: This method MUST always return a 0 (ERROR_SUCCESS), even in case of
	// errors.
	//
	//	+-------------------+------------------+
	//	|      RETURN       |                  |
	//	|    VALUE/CODE     |   DESCRIPTION    |
	//	|                   |                  |
	//	+-------------------+------------------+
	//	+-------------------+------------------+
	//	| 0 ERROR_SUCCESS   | Always returned. |
	//	+-------------------+------------------+
	OpenPerformanceText(context.Context, *OpenPerformanceTextRequest, ...dcerpc.CallOption) (*OpenPerformanceTextResponse, error)

	// The OpenPerformanceNlsText method is called by the client. In response, the server
	// opens a handle to the HKEY_PERFORMANCE_NLSTEXT predefined key. The HKEY_PERFORMANCE_NLSTEXT
	//  predefined key is used to retrieve performance information from a registry server
	// using only the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: This method MUST always return a 0 (ERROR_SUCCESS), even in case of
	// errors.
	//
	//	+-------------------+------------------+
	//	|      RETURN       |                  |
	//	|    VALUE/CODE     |   DESCRIPTION    |
	//	|                   |                  |
	//	+-------------------+------------------+
	//	+-------------------+------------------+
	//	| 0 ERROR_SUCCESS   | Always returned. |
	//	+-------------------+------------------+
	OpenPerformanceNlsText(context.Context, *OpenPerformanceNlsTextRequest, ...dcerpc.CallOption) (*OpenPerformanceNlsTextResponse, error)

	// The BaseRegQueryMultipleValues2 method is called by the client. In response, the
	// server returns the type and data for a client-specified list of value names that
	// are associated with the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED        | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER    | A parameter is incorrect.                                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000078 ERROR_CALL_NOT_IMPLEMENTED | This function is not supported on this system.                                   |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA            | More data is available.                                                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT        | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                       | server can no longer service registry requests because server shutdown has been  |
	//	|                                       | initiated.                                                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryMultipleValues2(context.Context, *BaseRegQueryMultipleValues2Request, ...dcerpc.CallOption) (*BaseRegQueryMultipleValues2Response, error)

	// The BaseRegDeleteKeyEx method is called by the client. In response, the server deletes
	// the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteKeyEx(context.Context, *BaseRegDeleteKeyExRequest, ...dcerpc.CallOption) (*BaseRegDeleteKeyExResponse, error)

	// AlterContext alters the client context.
	AlterContext(context.Context, ...dcerpc.Option) error
}

type WinregServer interface {

	// The OpenClassesRoot method is called by the client. In response, the server opens
	// the HKEY_CLASSES_ROOT  predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenClassesRoot(context.Context, *OpenClassesRootRequest) (*OpenClassesRootResponse, error)

	// The OpenCurrentUser method is called by the client. In response, the server opens
	// a handle to the HKEY_CURRENT_USER key. The server MUST determine which subkey of
	// HKEY_USERS is the correct key to map to HKEY_CURRENT_USER, as explained in section
	// 3.1.1.8.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated (SHUTDOWNINPROGRESS is set to TRUE).                                   |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenCurrentUser(context.Context, *OpenCurrentUserRequest) (*OpenCurrentUserResponse, error)

	// The OpenLocalMachine method is called by the client. In response, the server opens
	// a handle to the HKEY_LOCAL_MACHINE predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenLocalMachine(context.Context, *OpenLocalMachineRequest) (*OpenLocalMachineResponse, error)

	// The OpenPerformanceData method is called by the client. In response, the server opens
	// a handle to the HKEY_PERFORMANCE_DATA predefined key. The HKEY_PERFORMANCE_DATA  predefined
	// key is used to retrieve performance information from a registry server using only
	// the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The server
	// SHOULD return without modification any other error code encountered in servicing
	// the client request.
	//
	// The most common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenPerformanceData(context.Context, *OpenPerformanceDataRequest) (*OpenPerformanceDataResponse, error)

	// The OpenUsers method is called by the client. In response, the server opens a handle
	// to the HKEY_USERS predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The server
	// SHOULD return without modification any error code encountered in servicing the client
	// request.
	//
	// The most common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenUsers(context.Context, *OpenUsersRequest) (*OpenUsersResponse, error)

	// The BaseRegCloseKey method is called by the client. In response, the server destroys
	// (closes) the handle to the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN              |                                                                                  |
	//	|           VALUE/CODE            |                                   DESCRIPTION                                    |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000006 ERROR_INVALID_HANDLE | The handle is invalid.                                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000AA ERROR_BUSY           | The requested resource is in use.                                                |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT  | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                 | server can no longer service registry requests because server shutdown has been  |
	//	|                                 | initiated.                                                                       |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000015 ERROR_NOT_READY      | The service is not read. Calls can be repeated at a later time.                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000102 WAIT_TIMEOUT         | The wait operation timed out.                                                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	BaseRegCloseKey(context.Context, *BaseRegCloseKeyRequest) (*BaseRegCloseKeyResponse, error)

	// The BaseRegCreateKey method is called by the client. In response, the server creates
	// the specified registry key and returns a handle to the newly created key. If the
	// key already exists in the registry, a handle to the existing key is opened and returned.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_CREATE_SUB_KEY access rights.                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | Access is denied.                                                                |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegCreateKey(context.Context, *BaseRegCreateKeyRequest) (*BaseRegCreateKeyResponse, error)

	// The BaseRegDeleteKey method is called by the client. In response, the server deletes
	// the specified subkey.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | Access is denied. For BaseRegDeleteKey, this error will be returned when the key |
	//	|                                    | indicated by the lpSubKey parameter has subkeys.                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteKey(context.Context, *BaseRegDeleteKeyRequest) (*BaseRegDeleteKeyResponse, error)

	// The BaseRegDeleteValue method is called by the client. In response, the server removes
	// a named value from the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_SET_VALUE access rights.                            |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteValue(context.Context, *BaseRegDeleteValueRequest) (*BaseRegDeleteValueResponse, error)

	// The BaseRegEnumKey method is called by the client in order to enumerate a subkey.
	// In response, the server returns a requested subkey.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_ENUMERATE_SUB_KEYS access rights.                   |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY       | Not enough storage is available to complete this operation.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000103 ERROR_NO_MORE_ITEMS     | No more data is available.                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The size of the buffer is not large enough to hold the requested data.           |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegEnumKey(context.Context, *BaseRegEnumKeyRequest) (*BaseRegEnumKeyResponse, error)

	// The BaseRegEnumValue method is called by the client. In response, the server enumerates
	// the value at the specified index for the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2 The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                |                                                                                  |
	//	|              VALUE/CODE              |                                   DESCRIPTION                                    |
	//	|                                      |                                                                                  |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED       | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY         | Not enough storage is available to complete this operation.                      |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER   | A parameter is incorrect.                                                        |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000007A ERROR_INSUFFICIENT_BUFFER | The data area passed to a system call is too small.                              |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA           | More data is available.                                                          |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000103 ERROR_NO_MORE_ITEMS       | No more data is available.                                                       |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT       | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                      | server can no longer service registry requests because server shutdown has been  |
	//	|                                      | initiated.                                                                       |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	BaseRegEnumValue(context.Context, *BaseRegEnumValueRequest) (*BaseRegEnumValueResponse, error)

	// The BaseRegFlushKey method is called by the client. In response, the server writes
	// all of the subkeys and values of the key indicated by the hKey parameter to the backing
	// store for registry data.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2.
	//
	//	+--------------------------------+---------------------------------------------------------+
	//	|             RETURN             |                                                         |
	//	|           VALUE/CODE           |                       DESCRIPTION                       |
	//	|                                |                                                         |
	//	+--------------------------------+---------------------------------------------------------+
	//	+--------------------------------+---------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | The caller does not have KEY_QUERY_VALUE access rights. |
	//	+--------------------------------+---------------------------------------------------------+
	BaseRegFlushKey(context.Context, *BaseRegFlushKeyRequest) (*BaseRegFlushKeyResponse, error)

	// The BaseRegGetKeySecurity method is called by the client. In response, the server
	// returns a copy of the security descriptor that protects the specified open registry
	// key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x0000000E ERROR_OUTOFMEMORY       | Not enough storage is available to complete this operation.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegGetKeySecurity(context.Context, *BaseRegGetKeySecurityRequest) (*BaseRegGetKeySecurityResponse, error)

	// The BaseRegLoadKey method is called by the client. In response, the server loads
	// key, subkey, and value data from a file and inserts the data into the registry hierarchy.
	//
	// The BaseRegLoadKey method is designed for use in backup and recovery scenarios where
	// the client first loads a registry hive from a file on disk using the BaseRegLoadKey
	// method. Then, after reading or writing key data from the loaded hive, the client
	// uses the BaseRegUnLoadKey method to unload the hive. For example, a backup application
	// loads another user hive (another user's HKEY_CURRENT_USER ) from a file on disk using
	// the BaseRegLoadKey method. After reading key and value data, it will unload the hive
	// using the BaseRegUnLoadKey method.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000003F9 ERROR_NOT_REGISTRY_FILE | The system attempted to load or restore a file into the registry, but the        |
	//	|                                    | specified file is not in a registry file format.                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegLoadKey(context.Context, *BaseRegLoadKeyRequest) (*BaseRegLoadKeyResponse, error)

	// The BaseRegOpenKey method is called by the client. In response, the server opens
	// a specified key for access and returns a handle to it.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2.
	BaseRegOpenKey(context.Context, *BaseRegOpenKeyRequest) (*BaseRegOpenKeyResponse, error)

	// The BaseRegQueryInfoKey method is called by the client. In response, the server returns
	// relevant information on the key that corresponds to the specified key handle.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The size of the buffer is not large enough to hold the requested data.           |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryInfoKey(context.Context, *BaseRegQueryInfoKeyRequest) (*BaseRegQueryInfoKeyResponse, error)

	// The BaseRegQueryValue method is called by the client. In response, the server returns
	// the data that is associated with the named value of a specified registry open key.
	// If a value name is not specified, the server returns the data that is associated
	// with the default value of the specified registry open key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000002 ERROR_FILE_NOT_FOUND    | The value specified by lpValueName was not found. If lpValueName was not         |
	//	|                                    | specified, the default value has not been defined.                               |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA         | The data to be returned is larger than the buffer provided.                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryValue(context.Context, *BaseRegQueryValueRequest) (*BaseRegQueryValueResponse, error)

	// The BaseRegReplaceKey method is called by the client. In response, the server MUST
	// read the registry information from the specified file and replace the specified key
	// with the content of the file. When the system is started again, the key and subkeys
	// have the same values as those in the specified file.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000011 ERROR_NOT_SAME_DEVICE   | The file indicated by lpOldFile is not on the same physical volume as the file   |
	//	|                                    | indicated by lpNewFile.                                                          |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegReplaceKey(context.Context, *BaseRegReplaceKeyRequest) (*BaseRegReplaceKeyResponse, error)

	// The BaseRegRestoreKey method is called by the client. In response, the server reads
	// the registry information in a specified file and copies it over the specified key.
	// The registry information takes the form of a key and multiple levels of subkeys.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegRestoreKey(context.Context, *BaseRegRestoreKeyRequest) (*BaseRegRestoreKeyResponse, error)

	// The BaseRegSaveKey method is called by the client. In response, the server saves
	// the specified key, subkeys, and values to a new file.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in either [MS-ERREF] section 2.2 or
	// [MS-ERREF] section 2.3.1. The most common error codes are listed in the following
	// table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSaveKey(context.Context, *BaseRegSaveKeyRequest) (*BaseRegSaveKeyResponse, error)

	// The BaseRegSetKeySecurity method is called by the client. In response, the server
	// sets the security descriptor that protects the specified open registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSetKeySecurity(context.Context, *BaseRegSetKeySecurityRequest) (*BaseRegSetKeySecurityResponse, error)

	// The BaseRegSetValue method is called by the client. In response, the server sets
	// the data for the specified value of a registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The caller does not have KEY_SET_VALUE access rights, or the value being set to  |
	//	|                                    | a symbolic key is not the literal string "SymbolicLinkValue".                    |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSetValue(context.Context, *BaseRegSetValueRequest) (*BaseRegSetValueResponse, error)

	// The BaseRegUnLoadKey method is called by the client. In response, the server removes
	// the specified discrete body of keys, subkeys, and values that is rooted at the top
	// of the registry hierarchy.
	//
	// The BaseRegUnLoadKey method is designed for use in backup and recovery scenarios
	// where the client first loads a registry hive from a file on disk using the BaseRegLoadKey
	// method. Then, after reading or writing key data from the loaded hive, the client
	// uses the BaseRegUnLoadKey method to unload the hive. For example, a backup application
	// can load another user hive (another user's HKEY_CURRENT_USER) from a file on disk
	// using the BaseRegLoadKey method. Then, after reading key and value data, it will
	// unload the hive using the BaseRegUnLoadKey method.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000002 ERROR_FILE_NOT_FOUND    | The key specified by the handle hKey and the lpSubKey parameter does not exist   |
	//	|                                    | in the key namespace.                                                            |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The key specified by the handle hKey and the lpSubKey parameter is not a         |
	//	|                                    | descendent key of the HKEY_LOCAL_MACHINE or HKEY_USERS root keys, or there are   |
	//	|                                    | open handles to the key or its descendants.                                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegUnloadKey(context.Context, *BaseRegUnloadKeyRequest) (*BaseRegUnloadKeyResponse, error)

	// The BaseRegGetVersion method is called by the client. In response, the server returns
	// the version of the remote registry server. The BaseRegGetVersion method is used by
	// the client and the server to determine if the remote registry server supports both
	// 32-bit and 64-bit key namespaces.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns the following nonzero error code.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000003E6 ERROR_NOACCESS      | Invalid access to memory location.                                               |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	BaseRegGetVersion(context.Context, *BaseRegGetVersionRequest) (*BaseRegGetVersionResponse, error)

	// The OpenCurrentConfig method is called by the client. In response, the server attempts
	// to open a handle to the HKEY_CURRENT_CONFIG predefined key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|             RETURN             |                                                                                  |
	//	|           VALUE/CODE           |                                   DESCRIPTION                                    |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED | Access is denied.                                                                |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                | server can no longer service registry requests because server shutdown has been  |
	//	|                                | initiated.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	OpenCurrentConfig(context.Context, *OpenCurrentConfigRequest) (*OpenCurrentConfigResponse, error)

	// The BaseRegQueryMultipleValues method is called by the client. In response, the server
	// returns the type and data for a client-specified list of value names that are associated
	// with the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED        | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER    | A parameter is incorrect.                                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000078 ERROR_CALL_NOT_IMPLEMENTED | This function is not supported on this system.                                   |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT        | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                       | server can no longer service registry requests because server shutdown has been  |
	//	|                                       | initiated.                                                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryMultipleValues(context.Context, *BaseRegQueryMultipleValuesRequest) (*BaseRegQueryMultipleValuesResponse, error)

	// The BaseRegSaveKeyEx method is called by the client. In response, the server saves
	// the specified key, subkeys, and values to a new file. The BaseRegSaveKeyEx method
	// accepts flags that determine the format for the saved key or and values.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED     | The server does not have access permissions to save the file at the specified    |
	//	|                                    | location.                                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000B7 ERROR_ALREADY_EXISTS    | Cannot create a file when that file already exists.                              |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegSaveKeyEx(context.Context, *BaseRegSaveKeyExRequest) (*BaseRegSaveKeyExResponse, error)

	// The OpenPerformanceText method is called by the client. In response, the server opens
	// a handle to the HKEY_PERFORMANCE_TEXT predefined key. The HKEY_PERFORMANCE_TEXT predefined
	// key is used to retrieve performance information from a registry server using only
	// the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: This method MUST always return a 0 (ERROR_SUCCESS), even in case of
	// errors.
	//
	//	+-------------------+------------------+
	//	|      RETURN       |                  |
	//	|    VALUE/CODE     |   DESCRIPTION    |
	//	|                   |                  |
	//	+-------------------+------------------+
	//	+-------------------+------------------+
	//	| 0 ERROR_SUCCESS   | Always returned. |
	//	+-------------------+------------------+
	OpenPerformanceText(context.Context, *OpenPerformanceTextRequest) (*OpenPerformanceTextResponse, error)

	// The OpenPerformanceNlsText method is called by the client. In response, the server
	// opens a handle to the HKEY_PERFORMANCE_NLSTEXT predefined key. The HKEY_PERFORMANCE_NLSTEXT
	//  predefined key is used to retrieve performance information from a registry server
	// using only the BaseRegQueryInfoKey, BaseRegQueryValue, BaseRegEnumValue, and BaseRegCloseKey
	// methods.
	//
	// Return Values: This method MUST always return a 0 (ERROR_SUCCESS), even in case of
	// errors.
	//
	//	+-------------------+------------------+
	//	|      RETURN       |                  |
	//	|    VALUE/CODE     |   DESCRIPTION    |
	//	|                   |                  |
	//	+-------------------+------------------+
	//	+-------------------+------------------+
	//	| 0 ERROR_SUCCESS   | Always returned. |
	//	+-------------------+------------------+
	OpenPerformanceNlsText(context.Context, *OpenPerformanceNlsTextRequest) (*OpenPerformanceNlsTextResponse, error)

	// The BaseRegQueryMultipleValues2 method is called by the client. In response, the
	// server returns the type and data for a client-specified list of value names that
	// are associated with the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000005 ERROR_ACCESS_DENIED        | The caller does not have KEY_QUERY_VALUE access rights.                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER    | A parameter is incorrect.                                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000078 ERROR_CALL_NOT_IMPLEMENTED | This function is not supported on this system.                                   |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x000000EA ERROR_MORE_DATA            | More data is available.                                                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT        | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                       | server can no longer service registry requests because server shutdown has been  |
	//	|                                       | initiated.                                                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	BaseRegQueryMultipleValues2(context.Context, *BaseRegQueryMultipleValues2Request) (*BaseRegQueryMultipleValues2Response, error)

	// The BaseRegDeleteKeyEx method is called by the client. In response, the server deletes
	// the specified registry key.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) to indicate success; otherwise,
	// it returns a nonzero error code, as specified in [MS-ERREF] section 2.2. The most
	// common error codes are listed in the following table.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|               RETURN               |                                                                                  |
	//	|             VALUE/CODE             |                                   DESCRIPTION                                    |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000057 ERROR_INVALID_PARAMETER | A parameter is incorrect.                                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000013 ERROR_WRITE_PROTECT     | A read or write operation was attempted to a volume after it was dismounted. The |
	//	|                                    | server can no longer service registry requests because server shutdown has been  |
	//	|                                    | initiated.                                                                       |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	BaseRegDeleteKeyEx(context.Context, *BaseRegDeleteKeyExRequest) (*BaseRegDeleteKeyExResponse, error)
}