winreg

package
v1.2.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 7, 2025 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const DACLSecurityInformation = 0x00000004

DACLSecurityInformation represents the DACL_SECURITY_INFORMATION RPC constant

View Source 
const GroupSecurityInformation = 0x00000002

GroupSecurityInformation represents the GROUP_SECURITY_INFORMATION RPC constant

View Source 
const KeyCreateLink = 0x00000020

KeyCreateLink represents the KEY_CREATE_LINK RPC constant

View Source 
const KeyCreateSubKey = 0x00000004

KeyCreateSubKey represents the KEY_CREATE_SUB_KEY RPC constant

View Source 
const KeyEnumerateSubKeys = 0x00000008

KeyEnumerateSubKeys represents the KEY_ENUMERATE_SUB_KEYS RPC constant

View Source 
const KeyQueryValue = 0x00000001

KeyQueryValue represents the KEY_QUERY_VALUE RPC constant

View Source 
const KeySetValue = 0x00000002

KeySetValue represents the KEY_SET_VALUE RPC constant

View Source 
const KeyWOW6432Key = 0x00000200

KeyWOW6432Key represents the KEY_WOW64_32KEY RPC constant

View Source 
const KeyWOW6464Key = 0x00000100

KeyWOW6464Key represents the KEY_WOW64_64KEY RPC constant

View Source 
const OwnerSecurityInformation = 0x00000001

OwnerSecurityInformation represents the OWNER_SECURITY_INFORMATION RPC constant

View Source 
const RegBinary = 0x00000003

RegBinary represents the REG_BINARY RPC constant

View Source 
const RegDword = 0x00000004

RegDword represents the REG_DWORD RPC constant

View Source 
const RegDwordBigEndian = 0x00000005

RegDwordBigEndian represents the REG_DWORD_BIG_ENDIAN RPC constant

View Source 
const RegDwordLittleEndian = 0x00000004

RegDwordLittleEndian represents the REG_DWORD_LITTLE_ENDIAN RPC constant

View Source 
const RegExpandString = 0x00000002

RegExpandString represents the REG_EXPAND_SZ RPC constant

View Source 
const RegLink = 0x00000006

RegLink represents the REG_LINK RPC constant

View Source 
const RegMultistring = 0x00000007

RegMultistring represents the REG_MULTI_SZ RPC constant

View Source 
const RegNone = 0x00000000

RegNone represents the REG_NONE RPC constant

View Source 
const RegQword = 0x0000000B

RegQword represents the REG_QWORD RPC constant

View Source 
const RegQwordLittleEndian = 0x0000000B

RegQwordLittleEndian represents the REG_QWORD_LITTLE_ENDIAN RPC constant

View Source 
const RegString = 0x00000001

RegString represents the REG_SZ RPC constant

View Source 
const SACLSecurityInformation = 0x00000008

SACLSecurityInformation represents the SACL_SECURITY_INFORMATION RPC constant

Variables

View Source 
var (
	// Syntax UUID
	WinregSyntaxUUID = &uuid.UUID{TimeLow: 0x338cd001, TimeMid: 0x2244, TimeHiAndVersion: 0x31f1, ClockSeqHiAndReserved: 0xaa, ClockSeqLow: 0xaa, Node: [6]uint8{0x90, 0x0, 0x38, 0x0, 0x10, 0x3}}
	// Syntax ID
	WinregSyntaxV1_0 = &dcerpc.SyntaxID{IfUUID: WinregSyntaxUUID, IfVersionMajor: 1, IfVersionMinor: 0}
)
View Source 
var (
	// import guard
	GoPackage = "rrp"
)

Functions

func NewWinregServerHandle 

func NewWinregServerHandle(o WinregServer) dcerpc.ServerHandle

func RegisterWinregServer 

func RegisterWinregServer(conn dcerpc.Conn, o WinregServer, opts ...dcerpc.Option)

func WinregServerHandle 

func WinregServerHandle(ctx context.Context, o WinregServer, opNum int, r ndr.Reader) (dcerpc.Operation, error)

Types

type BaseRegCloseKeyRequest 

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"`
}

BaseRegCloseKeyRequest structure represents the BaseRegCloseKey operation request

func (*BaseRegCloseKeyRequest) MarshalNDR 

func (o *BaseRegCloseKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegCloseKeyRequest) UnmarshalNDR 

func (o *BaseRegCloseKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegCloseKeyResponse 

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"`
}

BaseRegCloseKeyResponse structure represents the BaseRegCloseKey operation response

func (*BaseRegCloseKeyResponse) MarshalNDR 

func (o *BaseRegCloseKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegCloseKeyResponse) UnmarshalNDR 

func (o *BaseRegCloseKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegCreateKeyRequest 

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"`
}

BaseRegCreateKeyRequest structure represents the BaseRegCreateKey operation request

func (*BaseRegCreateKeyRequest) MarshalNDR 

func (o *BaseRegCreateKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegCreateKeyRequest) UnmarshalNDR 

func (o *BaseRegCreateKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegCreateKeyResponse 

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"`
}

BaseRegCreateKeyResponse structure represents the BaseRegCreateKey operation response

func (*BaseRegCreateKeyResponse) MarshalNDR 

func (o *BaseRegCreateKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegCreateKeyResponse) UnmarshalNDR 

func (o *BaseRegCreateKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteKeyExRequest 

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"`
}

BaseRegDeleteKeyExRequest structure represents the BaseRegDeleteKeyEx operation request

func (*BaseRegDeleteKeyExRequest) MarshalNDR 

func (o *BaseRegDeleteKeyExRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteKeyExRequest) UnmarshalNDR 

func (o *BaseRegDeleteKeyExRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteKeyExResponse 

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

BaseRegDeleteKeyExResponse structure represents the BaseRegDeleteKeyEx operation response

func (*BaseRegDeleteKeyExResponse) MarshalNDR 

func (o *BaseRegDeleteKeyExResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteKeyExResponse) UnmarshalNDR 

func (o *BaseRegDeleteKeyExResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteKeyRequest 

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"`
}

BaseRegDeleteKeyRequest structure represents the BaseRegDeleteKey operation request

func (*BaseRegDeleteKeyRequest) MarshalNDR 

func (o *BaseRegDeleteKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteKeyRequest) UnmarshalNDR 

func (o *BaseRegDeleteKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteKeyResponse 

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

BaseRegDeleteKeyResponse structure represents the BaseRegDeleteKey operation response

func (*BaseRegDeleteKeyResponse) MarshalNDR 

func (o *BaseRegDeleteKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteKeyResponse) UnmarshalNDR 

func (o *BaseRegDeleteKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteValueRequest 

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"`
}

BaseRegDeleteValueRequest structure represents the BaseRegDeleteValue operation request

func (*BaseRegDeleteValueRequest) MarshalNDR 

func (o *BaseRegDeleteValueRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteValueRequest) UnmarshalNDR 

func (o *BaseRegDeleteValueRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegDeleteValueResponse 

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

BaseRegDeleteValueResponse structure represents the BaseRegDeleteValue operation response

func (*BaseRegDeleteValueResponse) MarshalNDR 

func (o *BaseRegDeleteValueResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegDeleteValueResponse) UnmarshalNDR 

func (o *BaseRegDeleteValueResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegEnumKeyRequest 

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"`
}

BaseRegEnumKeyRequest structure represents the BaseRegEnumKey operation request

func (*BaseRegEnumKeyRequest) MarshalNDR 

func (o *BaseRegEnumKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegEnumKeyRequest) UnmarshalNDR 

func (o *BaseRegEnumKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegEnumKeyResponse 

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"`
}

BaseRegEnumKeyResponse structure represents the BaseRegEnumKey operation response

func (*BaseRegEnumKeyResponse) MarshalNDR 

func (o *BaseRegEnumKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegEnumKeyResponse) UnmarshalNDR 

func (o *BaseRegEnumKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegEnumValueRequest 

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"`
}

BaseRegEnumValueRequest structure represents the BaseRegEnumValue operation request

func (*BaseRegEnumValueRequest) MarshalNDR 

func (o *BaseRegEnumValueRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegEnumValueRequest) UnmarshalNDR 

func (o *BaseRegEnumValueRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegEnumValueResponse 

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"`
}

BaseRegEnumValueResponse structure represents the BaseRegEnumValue operation response

func (*BaseRegEnumValueResponse) MarshalNDR 

func (o *BaseRegEnumValueResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegEnumValueResponse) UnmarshalNDR 

func (o *BaseRegEnumValueResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegFlushKeyRequest 

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"`
}

BaseRegFlushKeyRequest structure represents the BaseRegFlushKey operation request

func (*BaseRegFlushKeyRequest) MarshalNDR 

func (o *BaseRegFlushKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegFlushKeyRequest) UnmarshalNDR 

func (o *BaseRegFlushKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegFlushKeyResponse 

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

BaseRegFlushKeyResponse structure represents the BaseRegFlushKey operation response

func (*BaseRegFlushKeyResponse) MarshalNDR 

func (o *BaseRegFlushKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegFlushKeyResponse) UnmarshalNDR 

func (o *BaseRegFlushKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegGetKeySecurityRequest 

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"`
}

BaseRegGetKeySecurityRequest structure represents the BaseRegGetKeySecurity operation request

func (*BaseRegGetKeySecurityRequest) MarshalNDR 

func (o *BaseRegGetKeySecurityRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegGetKeySecurityRequest) UnmarshalNDR 

func (o *BaseRegGetKeySecurityRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegGetKeySecurityResponse 

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"`
}

BaseRegGetKeySecurityResponse structure represents the BaseRegGetKeySecurity operation response

func (*BaseRegGetKeySecurityResponse) MarshalNDR 

func (o *BaseRegGetKeySecurityResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegGetKeySecurityResponse) UnmarshalNDR 

func (o *BaseRegGetKeySecurityResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegGetVersionRequest 

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"`
}

BaseRegGetVersionRequest structure represents the BaseRegGetVersion operation request

func (*BaseRegGetVersionRequest) MarshalNDR 

func (o *BaseRegGetVersionRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegGetVersionRequest) UnmarshalNDR 

func (o *BaseRegGetVersionRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegGetVersionResponse 

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"`
}

BaseRegGetVersionResponse structure represents the BaseRegGetVersion operation response

func (*BaseRegGetVersionResponse) MarshalNDR 

func (o *BaseRegGetVersionResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegGetVersionResponse) UnmarshalNDR 

func (o *BaseRegGetVersionResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegLoadKeyRequest 

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"`
}

BaseRegLoadKeyRequest structure represents the BaseRegLoadKey operation request

func (*BaseRegLoadKeyRequest) MarshalNDR 

func (o *BaseRegLoadKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegLoadKeyRequest) UnmarshalNDR 

func (o *BaseRegLoadKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegLoadKeyResponse 

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

BaseRegLoadKeyResponse structure represents the BaseRegLoadKey operation response

func (*BaseRegLoadKeyResponse) MarshalNDR 

func (o *BaseRegLoadKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegLoadKeyResponse) UnmarshalNDR 

func (o *BaseRegLoadKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegOpenKeyRequest 

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"`
}

BaseRegOpenKeyRequest structure represents the BaseRegOpenKey operation request

func (*BaseRegOpenKeyRequest) MarshalNDR 

func (o *BaseRegOpenKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegOpenKeyRequest) UnmarshalNDR 

func (o *BaseRegOpenKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegOpenKeyResponse 

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"`
}

BaseRegOpenKeyResponse structure represents the BaseRegOpenKey operation response

func (*BaseRegOpenKeyResponse) MarshalNDR 

func (o *BaseRegOpenKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegOpenKeyResponse) UnmarshalNDR 

func (o *BaseRegOpenKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryInfoKeyRequest 

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"`
}

BaseRegQueryInfoKeyRequest structure represents the BaseRegQueryInfoKey operation request

func (*BaseRegQueryInfoKeyRequest) MarshalNDR 

func (o *BaseRegQueryInfoKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryInfoKeyRequest) UnmarshalNDR 

func (o *BaseRegQueryInfoKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryInfoKeyResponse 

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"`
}

BaseRegQueryInfoKeyResponse structure represents the BaseRegQueryInfoKey operation response

func (*BaseRegQueryInfoKeyResponse) MarshalNDR 

func (o *BaseRegQueryInfoKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryInfoKeyResponse) UnmarshalNDR 

func (o *BaseRegQueryInfoKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryMultipleValues2Request 

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"`
}

BaseRegQueryMultipleValues2Request structure represents the BaseRegQueryMultipleValues2 operation request

func (*BaseRegQueryMultipleValues2Request) MarshalNDR 

func (o *BaseRegQueryMultipleValues2Request) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryMultipleValues2Request) UnmarshalNDR 

func (o *BaseRegQueryMultipleValues2Request) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryMultipleValues2Response 

type BaseRegQueryMultipleValues2Response struct {
	// XXX: num_vals is an implicit input depedency for output parameters
	ValsLength uint32 `idl:"name:num_vals" json:"vals_length"`
	// XXX: ldwTotsize is an implicit input depedency for output parameters
	TotalSize uint32 `idl:"name:ldwTotsize" json:"total_size"`

	// 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"`
}

BaseRegQueryMultipleValues2Response structure represents the BaseRegQueryMultipleValues2 operation response

func (*BaseRegQueryMultipleValues2Response) MarshalNDR 

func (o *BaseRegQueryMultipleValues2Response) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryMultipleValues2Response) UnmarshalNDR 

func (o *BaseRegQueryMultipleValues2Response) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryMultipleValuesRequest 

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"`
}

BaseRegQueryMultipleValuesRequest structure represents the BaseRegQueryMultipleValues operation request

func (*BaseRegQueryMultipleValuesRequest) MarshalNDR 

func (o *BaseRegQueryMultipleValuesRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryMultipleValuesRequest) UnmarshalNDR 

func (o *BaseRegQueryMultipleValuesRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryMultipleValuesResponse 

type BaseRegQueryMultipleValuesResponse struct {
	// XXX: num_vals is an implicit input depedency for output parameters
	ValsLength uint32 `idl:"name:num_vals" json:"vals_length"`

	// 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"`
}

BaseRegQueryMultipleValuesResponse structure represents the BaseRegQueryMultipleValues operation response

func (*BaseRegQueryMultipleValuesResponse) MarshalNDR 

func (o *BaseRegQueryMultipleValuesResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryMultipleValuesResponse) UnmarshalNDR 

func (o *BaseRegQueryMultipleValuesResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryValueRequest 

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"`
}

BaseRegQueryValueRequest structure represents the BaseRegQueryValue operation request

func (*BaseRegQueryValueRequest) MarshalNDR 

func (o *BaseRegQueryValueRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryValueRequest) UnmarshalNDR 

func (o *BaseRegQueryValueRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegQueryValueResponse 

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"`
}

BaseRegQueryValueResponse structure represents the BaseRegQueryValue operation response

func (*BaseRegQueryValueResponse) MarshalNDR 

func (o *BaseRegQueryValueResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegQueryValueResponse) UnmarshalNDR 

func (o *BaseRegQueryValueResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegReplaceKeyRequest 

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"`
}

BaseRegReplaceKeyRequest structure represents the BaseRegReplaceKey operation request

func (*BaseRegReplaceKeyRequest) MarshalNDR 

func (o *BaseRegReplaceKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegReplaceKeyRequest) UnmarshalNDR 

func (o *BaseRegReplaceKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegReplaceKeyResponse 

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

BaseRegReplaceKeyResponse structure represents the BaseRegReplaceKey operation response

func (*BaseRegReplaceKeyResponse) MarshalNDR 

func (o *BaseRegReplaceKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegReplaceKeyResponse) UnmarshalNDR 

func (o *BaseRegReplaceKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegRestoreKeyRequest 

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"`
}

BaseRegRestoreKeyRequest structure represents the BaseRegRestoreKey operation request

func (*BaseRegRestoreKeyRequest) MarshalNDR 

func (o *BaseRegRestoreKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegRestoreKeyRequest) UnmarshalNDR 

func (o *BaseRegRestoreKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegRestoreKeyResponse 

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

BaseRegRestoreKeyResponse structure represents the BaseRegRestoreKey operation response

func (*BaseRegRestoreKeyResponse) MarshalNDR 

func (o *BaseRegRestoreKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegRestoreKeyResponse) UnmarshalNDR 

func (o *BaseRegRestoreKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSaveKeyExRequest 

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"`
}

BaseRegSaveKeyExRequest structure represents the BaseRegSaveKeyEx operation request

func (*BaseRegSaveKeyExRequest) MarshalNDR 

func (o *BaseRegSaveKeyExRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSaveKeyExRequest) UnmarshalNDR 

func (o *BaseRegSaveKeyExRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSaveKeyExResponse 

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

BaseRegSaveKeyExResponse structure represents the BaseRegSaveKeyEx operation response

func (*BaseRegSaveKeyExResponse) MarshalNDR 

func (o *BaseRegSaveKeyExResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSaveKeyExResponse) UnmarshalNDR 

func (o *BaseRegSaveKeyExResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSaveKeyRequest 

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"`
}

BaseRegSaveKeyRequest structure represents the BaseRegSaveKey operation request

func (*BaseRegSaveKeyRequest) MarshalNDR 

func (o *BaseRegSaveKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSaveKeyRequest) UnmarshalNDR 

func (o *BaseRegSaveKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSaveKeyResponse 

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

BaseRegSaveKeyResponse structure represents the BaseRegSaveKey operation response

func (*BaseRegSaveKeyResponse) MarshalNDR 

func (o *BaseRegSaveKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSaveKeyResponse) UnmarshalNDR 

func (o *BaseRegSaveKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSetKeySecurityRequest 

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"`
}

BaseRegSetKeySecurityRequest structure represents the BaseRegSetKeySecurity operation request

func (*BaseRegSetKeySecurityRequest) MarshalNDR 

func (o *BaseRegSetKeySecurityRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSetKeySecurityRequest) UnmarshalNDR 

func (o *BaseRegSetKeySecurityRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSetKeySecurityResponse 

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

BaseRegSetKeySecurityResponse structure represents the BaseRegSetKeySecurity operation response

func (*BaseRegSetKeySecurityResponse) MarshalNDR 

func (o *BaseRegSetKeySecurityResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSetKeySecurityResponse) UnmarshalNDR 

func (o *BaseRegSetKeySecurityResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSetValueRequest 

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"`
}

BaseRegSetValueRequest structure represents the BaseRegSetValue operation request

func (*BaseRegSetValueRequest) MarshalNDR 

func (o *BaseRegSetValueRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSetValueRequest) UnmarshalNDR 

func (o *BaseRegSetValueRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegSetValueResponse 

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

BaseRegSetValueResponse structure represents the BaseRegSetValue operation response

func (*BaseRegSetValueResponse) MarshalNDR 

func (o *BaseRegSetValueResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegSetValueResponse) UnmarshalNDR 

func (o *BaseRegSetValueResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegUnloadKeyRequest 

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"`
}

BaseRegUnloadKeyRequest structure represents the BaseRegUnLoadKey operation request

func (*BaseRegUnloadKeyRequest) MarshalNDR 

func (o *BaseRegUnloadKeyRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegUnloadKeyRequest) UnmarshalNDR 

func (o *BaseRegUnloadKeyRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type BaseRegUnloadKeyResponse 

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

BaseRegUnloadKeyResponse structure represents the BaseRegUnLoadKey operation response

func (*BaseRegUnloadKeyResponse) MarshalNDR 

func (o *BaseRegUnloadKeyResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*BaseRegUnloadKeyResponse) UnmarshalNDR 

func (o *BaseRegUnloadKeyResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type Key 

type Key dcetypes.ContextHandle

Key structure represents RPC_HKEY RPC structure.

func (*Key) ContextHandle 

func (o *Key) ContextHandle() *dcetypes.ContextHandle

func (*Key) MarshalNDR 

func (o *Key) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Key) UnmarshalNDR 

func (o *Key) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type OpenClassesRootRequest 

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"`
}

OpenClassesRootRequest structure represents the OpenClassesRoot operation request

func (*OpenClassesRootRequest) MarshalNDR 

func (o *OpenClassesRootRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenClassesRootRequest) UnmarshalNDR 

func (o *OpenClassesRootRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenClassesRootResponse 

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"`
}

OpenClassesRootResponse structure represents the OpenClassesRoot operation response

func (*OpenClassesRootResponse) MarshalNDR 

func (o *OpenClassesRootResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenClassesRootResponse) UnmarshalNDR 

func (o *OpenClassesRootResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenCurrentConfigRequest 

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"`
}

OpenCurrentConfigRequest structure represents the OpenCurrentConfig operation request

func (*OpenCurrentConfigRequest) MarshalNDR 

func (o *OpenCurrentConfigRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenCurrentConfigRequest) UnmarshalNDR 

func (o *OpenCurrentConfigRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenCurrentConfigResponse 

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"`
}

OpenCurrentConfigResponse structure represents the OpenCurrentConfig operation response

func (*OpenCurrentConfigResponse) MarshalNDR 

func (o *OpenCurrentConfigResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenCurrentConfigResponse) UnmarshalNDR 

func (o *OpenCurrentConfigResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenCurrentUserRequest 

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"`
}

OpenCurrentUserRequest structure represents the OpenCurrentUser operation request

func (*OpenCurrentUserRequest) MarshalNDR 

func (o *OpenCurrentUserRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenCurrentUserRequest) UnmarshalNDR 

func (o *OpenCurrentUserRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenCurrentUserResponse 

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"`
}

OpenCurrentUserResponse structure represents the OpenCurrentUser operation response

func (*OpenCurrentUserResponse) MarshalNDR 

func (o *OpenCurrentUserResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenCurrentUserResponse) UnmarshalNDR 

func (o *OpenCurrentUserResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenLocalMachineRequest 

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"`
}

OpenLocalMachineRequest structure represents the OpenLocalMachine operation request

func (*OpenLocalMachineRequest) MarshalNDR 

func (o *OpenLocalMachineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenLocalMachineRequest) UnmarshalNDR 

func (o *OpenLocalMachineRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenLocalMachineResponse 

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"`
}

OpenLocalMachineResponse structure represents the OpenLocalMachine operation response

func (*OpenLocalMachineResponse) MarshalNDR 

func (o *OpenLocalMachineResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenLocalMachineResponse) UnmarshalNDR 

func (o *OpenLocalMachineResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceDataRequest 

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"`
}

OpenPerformanceDataRequest structure represents the OpenPerformanceData operation request

func (*OpenPerformanceDataRequest) MarshalNDR 

func (o *OpenPerformanceDataRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceDataRequest) UnmarshalNDR 

func (o *OpenPerformanceDataRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceDataResponse 

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"`
}

OpenPerformanceDataResponse structure represents the OpenPerformanceData operation response

func (*OpenPerformanceDataResponse) MarshalNDR 

func (o *OpenPerformanceDataResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceDataResponse) UnmarshalNDR 

func (o *OpenPerformanceDataResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceNlsTextRequest 

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"`
}

OpenPerformanceNlsTextRequest structure represents the OpenPerformanceNlsText operation request

func (*OpenPerformanceNlsTextRequest) MarshalNDR 

func (o *OpenPerformanceNlsTextRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceNlsTextRequest) UnmarshalNDR 

func (o *OpenPerformanceNlsTextRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceNlsTextResponse 

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"`
}

OpenPerformanceNlsTextResponse structure represents the OpenPerformanceNlsText operation response

func (*OpenPerformanceNlsTextResponse) MarshalNDR 

func (o *OpenPerformanceNlsTextResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceNlsTextResponse) UnmarshalNDR 

func (o *OpenPerformanceNlsTextResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceTextRequest 

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"`
}

OpenPerformanceTextRequest structure represents the OpenPerformanceText operation request

func (*OpenPerformanceTextRequest) MarshalNDR 

func (o *OpenPerformanceTextRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceTextRequest) UnmarshalNDR 

func (o *OpenPerformanceTextRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenPerformanceTextResponse 

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"`
}

OpenPerformanceTextResponse structure represents the OpenPerformanceText operation response

func (*OpenPerformanceTextResponse) MarshalNDR 

func (o *OpenPerformanceTextResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenPerformanceTextResponse) UnmarshalNDR 

func (o *OpenPerformanceTextResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenUsersRequest 

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"`
}

OpenUsersRequest structure represents the OpenUsers operation request

func (*OpenUsersRequest) MarshalNDR 

func (o *OpenUsersRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenUsersRequest) UnmarshalNDR 

func (o *OpenUsersRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OpenUsersResponse 

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"`
}

OpenUsersResponse structure represents the OpenUsers operation response

func (*OpenUsersResponse) MarshalNDR 

func (o *OpenUsersResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OpenUsersResponse) UnmarshalNDR 

func (o *OpenUsersResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SecurityAttributes 

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"`
}

SecurityAttributes structure represents RPC_SECURITY_ATTRIBUTES RPC structure.

The RPC_SECURITY_ATTRIBUTES structure represents security attributes that can be set through the Remote Procedure Call Protocol Extensions, as specified in [MS-CMRP] section 2.2.3.2.

func (*SecurityAttributes) MarshalNDR 

func (o *SecurityAttributes) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SecurityAttributes) UnmarshalNDR 

func (o *SecurityAttributes) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SecurityDescriptor 

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"`
}

SecurityDescriptor structure represents RPC_SECURITY_DESCRIPTOR RPC structure.

The RPC_SECURITY_DESCRIPTOR structure represents the RPC security descriptors.

func (*SecurityDescriptor) MarshalNDR 

func (o *SecurityDescriptor) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SecurityDescriptor) UnmarshalNDR 

func (o *SecurityDescriptor) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type UnicodeString 

type UnicodeString dtyp.UnicodeString

UnicodeString structure represents RRP_UNICODE_STRING RPC structure.

func (*UnicodeString) MarshalNDR 

func (o *UnicodeString) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*UnicodeString) UnicodeString 

func (o *UnicodeString) UnicodeString() *dtyp.UnicodeString

func (*UnicodeString) UnmarshalNDR 

func (o *UnicodeString) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type UnimplementedWinregServer added in v1.1.5 

type UnimplementedWinregServer struct {
}

Unimplemented winreg

func (UnimplementedWinregServer) BaseRegCloseKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegCloseKey(context.Context, *BaseRegCloseKeyRequest) (*BaseRegCloseKeyResponse, error)

func (UnimplementedWinregServer) BaseRegCreateKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegCreateKey(context.Context, *BaseRegCreateKeyRequest) (*BaseRegCreateKeyResponse, error)

func (UnimplementedWinregServer) BaseRegDeleteKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegDeleteKey(context.Context, *BaseRegDeleteKeyRequest) (*BaseRegDeleteKeyResponse, error)

func (UnimplementedWinregServer) BaseRegDeleteKeyEx added in v1.1.5 

func (UnimplementedWinregServer) BaseRegDeleteKeyEx(context.Context, *BaseRegDeleteKeyExRequest) (*BaseRegDeleteKeyExResponse, error)

func (UnimplementedWinregServer) BaseRegDeleteValue added in v1.1.5 

func (UnimplementedWinregServer) BaseRegDeleteValue(context.Context, *BaseRegDeleteValueRequest) (*BaseRegDeleteValueResponse, error)

func (UnimplementedWinregServer) BaseRegEnumKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegEnumKey(context.Context, *BaseRegEnumKeyRequest) (*BaseRegEnumKeyResponse, error)

func (UnimplementedWinregServer) BaseRegEnumValue added in v1.1.5 

func (UnimplementedWinregServer) BaseRegEnumValue(context.Context, *BaseRegEnumValueRequest) (*BaseRegEnumValueResponse, error)

func (UnimplementedWinregServer) BaseRegFlushKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegFlushKey(context.Context, *BaseRegFlushKeyRequest) (*BaseRegFlushKeyResponse, error)

func (UnimplementedWinregServer) BaseRegGetKeySecurity added in v1.1.5 

func (UnimplementedWinregServer) BaseRegGetKeySecurity(context.Context, *BaseRegGetKeySecurityRequest) (*BaseRegGetKeySecurityResponse, error)

func (UnimplementedWinregServer) BaseRegGetVersion added in v1.1.5 

func (UnimplementedWinregServer) BaseRegGetVersion(context.Context, *BaseRegGetVersionRequest) (*BaseRegGetVersionResponse, error)

func (UnimplementedWinregServer) BaseRegLoadKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegLoadKey(context.Context, *BaseRegLoadKeyRequest) (*BaseRegLoadKeyResponse, error)

func (UnimplementedWinregServer) BaseRegOpenKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegOpenKey(context.Context, *BaseRegOpenKeyRequest) (*BaseRegOpenKeyResponse, error)

func (UnimplementedWinregServer) BaseRegQueryInfoKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegQueryInfoKey(context.Context, *BaseRegQueryInfoKeyRequest) (*BaseRegQueryInfoKeyResponse, error)

func (UnimplementedWinregServer) BaseRegQueryMultipleValues added in v1.1.5 

func (UnimplementedWinregServer) BaseRegQueryMultipleValues(context.Context, *BaseRegQueryMultipleValuesRequest) (*BaseRegQueryMultipleValuesResponse, error)

func (UnimplementedWinregServer) BaseRegQueryMultipleValues2 added in v1.1.5 

func (UnimplementedWinregServer) BaseRegQueryMultipleValues2(context.Context, *BaseRegQueryMultipleValues2Request) (*BaseRegQueryMultipleValues2Response, error)

func (UnimplementedWinregServer) BaseRegQueryValue added in v1.1.5 

func (UnimplementedWinregServer) BaseRegQueryValue(context.Context, *BaseRegQueryValueRequest) (*BaseRegQueryValueResponse, error)

func (UnimplementedWinregServer) BaseRegReplaceKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegReplaceKey(context.Context, *BaseRegReplaceKeyRequest) (*BaseRegReplaceKeyResponse, error)

func (UnimplementedWinregServer) BaseRegRestoreKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegRestoreKey(context.Context, *BaseRegRestoreKeyRequest) (*BaseRegRestoreKeyResponse, error)

func (UnimplementedWinregServer) BaseRegSaveKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegSaveKey(context.Context, *BaseRegSaveKeyRequest) (*BaseRegSaveKeyResponse, error)

func (UnimplementedWinregServer) BaseRegSaveKeyEx added in v1.1.5 

func (UnimplementedWinregServer) BaseRegSaveKeyEx(context.Context, *BaseRegSaveKeyExRequest) (*BaseRegSaveKeyExResponse, error)

func (UnimplementedWinregServer) BaseRegSetKeySecurity added in v1.1.5 

func (UnimplementedWinregServer) BaseRegSetKeySecurity(context.Context, *BaseRegSetKeySecurityRequest) (*BaseRegSetKeySecurityResponse, error)

func (UnimplementedWinregServer) BaseRegSetValue added in v1.1.5 

func (UnimplementedWinregServer) BaseRegSetValue(context.Context, *BaseRegSetValueRequest) (*BaseRegSetValueResponse, error)

func (UnimplementedWinregServer) BaseRegUnloadKey added in v1.1.5 

func (UnimplementedWinregServer) BaseRegUnloadKey(context.Context, *BaseRegUnloadKeyRequest) (*BaseRegUnloadKeyResponse, error)

func (UnimplementedWinregServer) OpenClassesRoot added in v1.1.5 

func (UnimplementedWinregServer) OpenClassesRoot(context.Context, *OpenClassesRootRequest) (*OpenClassesRootResponse, error)

func (UnimplementedWinregServer) OpenCurrentConfig added in v1.1.5 

func (UnimplementedWinregServer) OpenCurrentConfig(context.Context, *OpenCurrentConfigRequest) (*OpenCurrentConfigResponse, error)

func (UnimplementedWinregServer) OpenCurrentUser added in v1.1.5 

func (UnimplementedWinregServer) OpenCurrentUser(context.Context, *OpenCurrentUserRequest) (*OpenCurrentUserResponse, error)

func (UnimplementedWinregServer) OpenLocalMachine added in v1.1.5 

func (UnimplementedWinregServer) OpenLocalMachine(context.Context, *OpenLocalMachineRequest) (*OpenLocalMachineResponse, error)

func (UnimplementedWinregServer) OpenPerformanceData added in v1.1.5 

func (UnimplementedWinregServer) OpenPerformanceData(context.Context, *OpenPerformanceDataRequest) (*OpenPerformanceDataResponse, error)

func (UnimplementedWinregServer) OpenPerformanceNlsText added in v1.1.5 

func (UnimplementedWinregServer) OpenPerformanceNlsText(context.Context, *OpenPerformanceNlsTextRequest) (*OpenPerformanceNlsTextResponse, error)

func (UnimplementedWinregServer) OpenPerformanceText added in v1.1.5 

func (UnimplementedWinregServer) OpenPerformanceText(context.Context, *OpenPerformanceTextRequest) (*OpenPerformanceTextResponse, error)

func (UnimplementedWinregServer) OpenUsers added in v1.1.5 

func (UnimplementedWinregServer) OpenUsers(context.Context, *OpenUsersRequest) (*OpenUsersResponse, error)

type ValueEntry 

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"`
}

ValueEntry structure represents RVALENT RPC structure.

The RVALENT structure is used to store the values and data that are associated with a key, as specified in section 3.1.5.26. The format of the RVALENT structure is as follows.

func (*ValueEntry) MarshalNDR 

func (o *ValueEntry) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ValueEntry) UnmarshalNDR 

func (o *ValueEntry) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type WinregClient 

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

	// Conn returns the client connection (unsafe)
	Conn() dcerpc.Conn
}

winreg interface.

func NewWinregClient 

func NewWinregClient(ctx context.Context, cc dcerpc.Conn, opts ...dcerpc.Option) (WinregClient, error)

type WinregServer 

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)
}

winreg server interface.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.