ieventservice

package
v1.1.3 Latest Latest
Warning

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

 Go to latest Published: Jan 30, 2025 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Syntax UUID
	EventServiceSyntaxUUID = &uuid.UUID{TimeLow: 0xf6beaff7, TimeMid: 0x1e19, TimeHiAndVersion: 0x4fbb, ClockSeqHiAndReserved: 0x9f, ClockSeqLow: 0x8f, Node: [6]uint8{0xb8, 0x9e, 0x20, 0x18, 0x33, 0x7c}}
	// Syntax ID
	EventServiceSyntaxV1_0 = &dcerpc.SyntaxID{IfUUID: EventServiceSyntaxUUID, IfVersionMajor: 1, IfVersionMinor: 0}
)
View Source 
var (
	// import guard
	GoPackage = "even6"
)
View Source 
var SubscribePull = 268435456

SubscribePull represents the EvtRpcSubscribePull RPC constant

View Source 
var VarFlagsModified = 1

VarFlagsModified represents the EvtRpcVarFlagsModified RPC constant

Functions

func EventServiceServerHandle 

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

func NewEventServiceServerHandle 

func NewEventServiceServerHandle(o EventServiceServer) dcerpc.ServerHandle

func RegisterEventServiceServer 

func RegisterEventServiceServer(conn dcerpc.Conn, o EventServiceServer, opts ...dcerpc.Option)

Types

type AssertConfigFlags 

type AssertConfigFlags uint32

AssertConfigFlags type represents EvtRpcAssertConfigFlags RPC enumeration.

The EvtRpcAssertConfigFlags Enumeration members specify how the path and channelPath parameters (used by a number of the methods in 3.1.4) are to be interpreted. 

var (
	// EvtRpcChannelPath:  The associated parameter string contains a path to a channel.
	AssertConfigFlagsChannelPath AssertConfigFlags = 0
	// EvtRpcPublisherName:  The associated parameter string contains a publisher name.
	AssertConfigFlagsPublisherName AssertConfigFlags = 1
)

func (AssertConfigFlags) String 

func (o AssertConfigFlags) String() string

type AssertConfigRequest 

type AssertConfigRequest struct {
	// path: A pointer to a string that contains a channel or publisher name to be updated.
	Path string `idl:"name:path;string" json:"path"`
	// flags: The client MUST specify exactly one of the following.
	//
	//	+--------------------------------+----------------------------------+
	//	|                                |                                  |
	//	|             VALUE              |             MEANING              |
	//	|                                |                                  |
	//	+--------------------------------+----------------------------------+
	//	+--------------------------------+----------------------------------+
	//	| EvtRpcChannelPath 0x00000000   | Path specifies a channel name.   |
	//	+--------------------------------+----------------------------------+
	//	| EvtRpcPublisherName 0x00000001 | Path specifies a publisher name. |
	//	+--------------------------------+----------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

AssertConfigRequest structure represents the EvtRpcAssertConfig operation request

func (*AssertConfigRequest) MarshalNDR 

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

func (*AssertConfigRequest) UnmarshalNDR 

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

type AssertConfigResponse 

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

AssertConfigResponse structure represents the EvtRpcAssertConfig operation response

func (*AssertConfigResponse) MarshalNDR 

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

func (*AssertConfigResponse) UnmarshalNDR 

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

type BooleanArray 

type BooleanArray struct {
	// count:  A 32-bit unsigned integer that contains the number of BOOLEAN values pointed
	// to by ptr.
	Count uint32 `idl:"name:count" json:"count"`
	// ptr:  A pointer to an array of BOOLEAN values.
	Array []bool `idl:"name:ptr;size_is:(count)" json:"array"`
}

BooleanArray structure represents BooleanArray RPC structure.

The BooleanArray structure is defined as follows.

func (*BooleanArray) MarshalNDR 

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

func (*BooleanArray) UnmarshalNDR 

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

type CancelRequest 

type CancelRequest struct {
	// handle: A handle obtained by any of the other methods in this interface. This parameter
	// is an RPC context handle, as specified in [C706], Context Handles.
	Handle *OperationControl `idl:"name:handle" json:"handle"`
}

CancelRequest structure represents the EvtRpcCancel operation request

func (*CancelRequest) MarshalNDR 

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

func (*CancelRequest) UnmarshalNDR 

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

type CancelResponse 

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

CancelResponse structure represents the EvtRpcCancel operation response

func (*CancelResponse) MarshalNDR 

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

func (*CancelResponse) UnmarshalNDR 

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

type ClearLogRequest 

type ClearLogRequest struct {
	// control: A handle to an operation control object. This parameter is an RPC context
	// handle, as specified in [C706], Context Handles.
	Control *OperationControl `idl:"name:control" json:"control"`
	// channelPath:  A pointer to a string that contains the path of the channel to be
	// cleared.
	ChannelPath string `idl:"name:channelPath;string" json:"channel_path"`
	// backupPath: A pointer to a string that contains the path of the file in which events
	// are to be saved before the clear is performed. A value of NULL indicates that no
	// backup event log is to be created (the events to be cleared are not to be saved).
	BackupPath string `idl:"name:backupPath;string;pointer:unique" json:"backup_path"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<25>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

ClearLogRequest structure represents the EvtRpcClearLog operation request

func (*ClearLogRequest) MarshalNDR 

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

func (*ClearLogRequest) UnmarshalNDR 

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

type ClearLogResponse 

type ClearLogResponse struct {
	// error: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise, it
	// MUST return an implementation-specific nonzero value as specified in [MS-ERREF].<26>
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcClearLog return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

ClearLogResponse structure represents the EvtRpcClearLog operation response

func (*ClearLogResponse) MarshalNDR 

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

func (*ClearLogResponse) UnmarshalNDR 

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

type CloseRequest 

type CloseRequest struct {
	// handle: This parameter is an RPC context handle, as specified in [C706], Context
	// Handles.
	Handle *dcetypes.ContextHandle `idl:"name:handle" json:"handle"`
}

CloseRequest structure represents the EvtRpcClose operation request

func (*CloseRequest) MarshalNDR 

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

func (*CloseRequest) UnmarshalNDR 

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

type CloseResponse 

type CloseResponse struct {
	// handle: This parameter is an RPC context handle, as specified in [C706], Context
	// Handles.
	Handle *dcetypes.ContextHandle `idl:"name:handle" json:"handle"`
	// Return: The EvtRpcClose return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

CloseResponse structure represents the EvtRpcClose operation response

func (*CloseResponse) MarshalNDR 

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

func (*CloseResponse) UnmarshalNDR 

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

type EventMetadataEnum 

type EventMetadataEnum dcetypes.ContextHandle

EventMetadataEnum structure represents PCONTEXT_HANDLE_EVENT_METADATA_ENUM RPC structure.

func (*EventMetadataEnum) ContextHandle 

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

func (*EventMetadataEnum) MarshalNDR 

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

func (*EventMetadataEnum) UnmarshalNDR 

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

type EventServiceClient 

type EventServiceClient interface {

	// The EvtRpcRegisterRemoteSubscription (Opnum 0) method is used by a client to create
	// either a push or a pull subscription. In push subscriptions, the server calls the
	// client when new events are ready. In pull subscriptions, the client polls the server
	// for new events. Subscriptions can be to either a single channel and its associated
	// log, or to multiple channels and their logs.
	//
	// A client can use bookmarks to ensure a reliable subscription even if the client is
	// not continuously connected. A client can create a bookmark locally based on the contents
	// of an event that the client has processed. If the client disconnects and later reconnects,
	// it can use the bookmark to pick up where it left off. For information on bookmarks,
	// see section 2.2.14.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterRemoteSubscription(context.Context, *RegisterRemoteSubscriptionRequest, ...dcerpc.CallOption) (*RegisterRemoteSubscriptionResponse, error)

	// The EvtRpcRemoteSubscriptionNextAsync (Opnum 1) method is used by a client to request
	// asynchronous delivery of events that are delivered to a subscription.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionNextAsync(context.Context, *RemoteSubscriptionNextAsyncRequest, ...dcerpc.CallOption) (*RemoteSubscriptionNextAsyncResponse, error)

	// This EvtRpcRemoteSubscriptionNext (Opnum 2) method is a synchronous request for events
	// that have been delivered to a subscription. This method is only used for pull subscriptions
	// in which the client polls for events. The EvtRpcRemoteSubscriptionWaitAsync (section
	// 3.1.4.11) method can be used along with this method to minimize the frequency of
	// polling.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_TIMEOUT (0x000005b4) if fewer than numRequestedRecords records
	// are found within the time-out period. Otherwise, it MUST return a different implementation-specific
	// nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionNext(context.Context, *RemoteSubscriptionNextRequest, ...dcerpc.CallOption) (*RemoteSubscriptionNextResponse, error)

	// Pull subscriptions are subscriptions in which the client requests records. The requests
	// can be done by using a polling mechanism. The EvtRpcRemoteSubscriptionWaitAsync (Opnum
	// 3) method can be used to enable the client to only poll when results are likely,
	// and is typically used in conjunction with the EvtRpcRemoteSubscriptionNext (Opnum
	// 2) (section 3.1.4.10) method, which is a blocking call; so this asynchronous method
	// is used to provide a way for the caller to not have to block or continuously poll
	// the server.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionWaitAsync(context.Context, *RemoteSubscriptionWaitAsyncRequest, ...dcerpc.CallOption) (*RemoteSubscriptionWaitAsyncResponse, error)

	// The EvtRpcRegisterControllableOperation (Opnum 4) method obtains a CONTEXT_HANDLE_OPERATION_CONTROL
	// handle that can be used to cancel other operations.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterControllableOperation(context.Context, *RegisterControllableOperationRequest, ...dcerpc.CallOption) (*RegisterControllableOperationResponse, error)

	// The EvtRpcRegisterLogQuery (Opnum 5) method is used to query one or more channels.
	// It can also be used to query a specific file. Actual retrieval of events is done
	// by subsequent calls to the EvtRpcQueryNext (section 3.1.4.13) method.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterLogQuery(context.Context, *RegisterLogQueryRequest, ...dcerpc.CallOption) (*RegisterLogQueryResponse, error)

	// The EvtRpcClearLog (Opnum 6) method instructs the server to clear all the events
	// in a live channel, and optionally, to create a backup event log before the clear
	// takes place.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) on success; otherwise, it MUST
	// return an implementation-specific nonzero value as specified in [MS-ERREF].
	//
	// The server does not validate the control handle passed to EvtRpcClearLog and it SHOULD
	// assume that this parameter is always valid when the method is invoked.
	ClearLog(context.Context, *ClearLogRequest, ...dcerpc.CallOption) (*ClearLogResponse, error)

	// The EvtRpcExportLog (Opnum 7) method instructs the server to create a backup event
	// log at a specified file name.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	//
	// The server does not validate the control handle passed to EvtRpcExportLog, and it
	// SHOULD assume that this parameter is always valid when the method is invoked.
	ExportLog(context.Context, *ExportLogRequest, ...dcerpc.CallOption) (*ExportLogResponse, error)

	// The EvtRpcLocalizeExportLog (Opnum 8) method is used by a client to add localized
	// information to a previously created backup event log, because the backup event log
	// does not contain the localized strings for event descriptions. An example of how
	// this can be useful is if a backup event log needs to be copied to other computers
	// so that support personnel on those other computers can access it; if this method
	// has been called, such support personnel can access or view the localized backup event
	// log, which will then contain events with localized strings. Note that a discussion
	// of tools by which administrators or support personnel can work with localized backup
	// event log files in scenarios such as this is out of scope with respect to this protocol
	// specification.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an error value as specified in the processing rules in this section.<33>
	// Callers SHOULD treat all return values other than ERROR_SUCCESS equally and not alter
	// their behavior based on any specific error values.
	//
	// The server does not validate the control handle passed to EvtRpcLocalizeExportLog,
	// and it SHOULD assume that this parameter is always valid when the method is invoked.
	LocalizeExportLog(context.Context, *LocalizeExportLogRequest, ...dcerpc.CallOption) (*LocalizeExportLogResponse, error)

	// The EvtRpcMessageRender (Opnum 9) method is used by a client to get localized descriptive
	// strings for an event.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if maxSizeString is too
	// small to hold the result string. In that case, neededSizeString MUST be set to the
	// necessary size. Otherwise, the method MUST return a different implementation-specific
	// nonzero value as specified in [MS-ERREF].
	MessageRender(context.Context, *MessageRenderRequest, ...dcerpc.CallOption) (*MessageRenderResponse, error)

	// The EvtRpcMessageRenderDefault (Opnum 10) method is used by a client to get localized
	// strings for common values of opcodes, tasks, or keywords, as specified in section
	// 3.1.4.31.
	//
	// Return Values:  The method MUST return the following value on success.
	//
	// ERROR_SUCCESS (0x00000000)
	//
	// The method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if maxSizeString is
	// too small to hold the result string. In that case, neededSizeString MUST be set to
	// the necessary size.
	//
	// Otherwise, the method MUST return a different implementation-specific nonzero value
	// as specified in [MS-ERREF].
	//
	// This method is the same as the EvtRpcMessageRender (section 3.1.4.31) method, except
	// that this method always uses the server's default strings (default strings come from
	// the server's default publisher, so a publisher handle is not required), whereas the
	// EvtRpcMessageRender (section 3.1.4.31) method uses only the default strings in the
	// case of level, task, opcode, and keyword values that fall in certain ranges. Therefore
	// it takes only 6 possible format flags. The server MUST fail the method with ERROR_INVALID_PARAMETER
	// (0x00000057) for any other flags than the 6 values given in the flags table.
	MessageRenderDefault(context.Context, *MessageRenderDefaultRequest, ...dcerpc.CallOption) (*MessageRenderDefaultResponse, error)

	// The EvtRpcQueryNext (Opnum 11) method is used by a client to get the next batch of
	// records from a query result set.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_TIMEOUT (0x000005bf) if no records are found within the
	// time-out period. The method MUST return ERROR_NO_MORE_ITEMS (0x00000103) once the
	// query has finished going through all the log(s); otherwise, it MUST return a different
	// implementation-specific nonzero value as specified in [MS-ERREF].
	QueryNext(context.Context, *QueryNextRequest, ...dcerpc.CallOption) (*QueryNextResponse, error)

	// The EvtRpcQuerySeek (Opnum 12) method is used by a client to move a query cursor
	// within a result set.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	QuerySeek(context.Context, *QuerySeekRequest, ...dcerpc.CallOption) (*QuerySeekResponse, error)

	// The EvtRpcClose (Opnum 13) method is used by a client to close context handles that
	// are opened by other methods in this protocol.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	Close(context.Context, *CloseRequest, ...dcerpc.CallOption) (*CloseResponse, error)

	// The EvtRpcCancel (Opnum 14) method is used by a client to cancel another method.
	// This can be used to terminate long-running methods gracefully. Methods that can be
	// canceled include the subscription and query functions, and other functions that take
	// a CONTEXT_HANDLE_OPERATION_CONTROL argument.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	Cancel(context.Context, *CancelRequest, ...dcerpc.CallOption) (*CancelResponse, error)

	// The EvtRpcAssertConfig (Opnum 15) method indicates to the server that the publisher
	// or channel configuration has been updated.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	AssertConfig(context.Context, *AssertConfigRequest, ...dcerpc.CallOption) (*AssertConfigResponse, error)

	// The EvtRpcRetractConfig (Opnum 16) method indicates to the server that the publisher
	// or channel is to be removed.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RetractConfig(context.Context, *RetractConfigRequest, ...dcerpc.CallOption) (*RetractConfigResponse, error)

	// The EvtRpcOpenLogHandle (Opnum 17) method is used by a client to get information
	// about a channel or a backup event log.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	OpenLog(context.Context, *OpenLogRequest, ...dcerpc.CallOption) (*OpenLogResponse, error)

	// The EvtRpcGetLogFileInfo (Opnum 18) method is used by a client to get information
	// about a live channel or a backup event log.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if the buffer is too small;
	// otherwise, it MUST return a different implementation-specific nonzero value as specified
	// in [MS-ERREF].
	GetLogFileInfo(context.Context, *GetLogFileInfoRequest, ...dcerpc.CallOption) (*GetLogFileInfoResponse, error)

	// The EvtRpcGetChannelList (Opnum 19) method is used to enumerate the set of available
	// channels.
	//
	// Return Values:  The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetChannelList(context.Context, *GetChannelListRequest, ...dcerpc.CallOption) (*GetChannelListResponse, error)

	// The EvtRpcGetChannelConfig (opnum 20) method is used by a client to get the configuration
	// for a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetChannelConfig(context.Context, *GetChannelConfigRequest, ...dcerpc.CallOption) (*GetChannelConfigResponse, error)

	// The EvtRpcPutChannelConfig (Opnum 21) method is used by a client to update the configuration
	// for a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].<42>
	PutChannelConfig(context.Context, *PutChannelConfigRequest, ...dcerpc.CallOption) (*PutChannelConfigResponse, error)

	// The EvtRpcGetPublisherList (Opnum 22) method is used by a client to get the list
	// of publishers.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherList(context.Context, *GetPublisherListRequest, ...dcerpc.CallOption) (*GetPublisherListResponse, error)

	// The EvtRpcGetPublisherListForChannel (Opnum 23) method is used by a client to get
	// the list of publishers that write events to a particular channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherListForChannel(context.Context, *GetPublisherListForChannelRequest, ...dcerpc.CallOption) (*GetPublisherListForChannelResponse, error)

	// The EvtRpcGetPublisherMetadata (Opnum 24) method is used by a client to open a handle
	// to publisher metadata. It also gets some initial information from the metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherMetadata(context.Context, *GetPublisherMetadataRequest, ...dcerpc.CallOption) (*GetPublisherMetadataResponse, error)

	// The EvtRpcGetPublisherResourceMetadata (Opnum 25) method obtains information from
	// the publisher metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherResourceMetadata(context.Context, *GetPublisherResourceMetadataRequest, ...dcerpc.CallOption) (*GetPublisherResourceMetadataResponse, error)

	// The EvtRpcGetEventMetadataEnum (Opnum 26) method obtains a handle for enumerating
	// a publisher's event metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetEventMetadataEnum(context.Context, *GetEventMetadataEnumRequest, ...dcerpc.CallOption) (*GetEventMetadataEnumResponse, error)

	// The EvtRpcGetNextEventMetadata (Opnum 27) method gets details about a possible event
	// and also returns the next event metadata in the enumeration. It is used to enumerate
	// through the event definitions for the publisher associated with the handle. The enumeration
	// is in the forward direction only, and there is no reset functionality.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetNextEventMetadata(context.Context, *GetNextEventMetadataRequest, ...dcerpc.CallOption) (*GetNextEventMetadataResponse, error)

	// The EvtRpcGetClassicLogDisplayName (Opnum 28) method obtains a descriptive name for
	// a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetClassicLogDisplayName(context.Context, *GetClassicLogDisplayNameRequest, ...dcerpc.CallOption) (*GetClassicLogDisplayNameResponse, error)

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

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

IEventService interface.

func NewEventServiceClient 

func NewEventServiceClient(ctx context.Context, cc dcerpc.Conn, opts ...dcerpc.Option) (EventServiceClient, error)

type EventServiceServer 

type EventServiceServer interface {

	// The EvtRpcRegisterRemoteSubscription (Opnum 0) method is used by a client to create
	// either a push or a pull subscription. In push subscriptions, the server calls the
	// client when new events are ready. In pull subscriptions, the client polls the server
	// for new events. Subscriptions can be to either a single channel and its associated
	// log, or to multiple channels and their logs.
	//
	// A client can use bookmarks to ensure a reliable subscription even if the client is
	// not continuously connected. A client can create a bookmark locally based on the contents
	// of an event that the client has processed. If the client disconnects and later reconnects,
	// it can use the bookmark to pick up where it left off. For information on bookmarks,
	// see section 2.2.14.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterRemoteSubscription(context.Context, *RegisterRemoteSubscriptionRequest) (*RegisterRemoteSubscriptionResponse, error)

	// The EvtRpcRemoteSubscriptionNextAsync (Opnum 1) method is used by a client to request
	// asynchronous delivery of events that are delivered to a subscription.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionNextAsync(context.Context, *RemoteSubscriptionNextAsyncRequest) (*RemoteSubscriptionNextAsyncResponse, error)

	// This EvtRpcRemoteSubscriptionNext (Opnum 2) method is a synchronous request for events
	// that have been delivered to a subscription. This method is only used for pull subscriptions
	// in which the client polls for events. The EvtRpcRemoteSubscriptionWaitAsync (section
	// 3.1.4.11) method can be used along with this method to minimize the frequency of
	// polling.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_TIMEOUT (0x000005b4) if fewer than numRequestedRecords records
	// are found within the time-out period. Otherwise, it MUST return a different implementation-specific
	// nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionNext(context.Context, *RemoteSubscriptionNextRequest) (*RemoteSubscriptionNextResponse, error)

	// Pull subscriptions are subscriptions in which the client requests records. The requests
	// can be done by using a polling mechanism. The EvtRpcRemoteSubscriptionWaitAsync (Opnum
	// 3) method can be used to enable the client to only poll when results are likely,
	// and is typically used in conjunction with the EvtRpcRemoteSubscriptionNext (Opnum
	// 2) (section 3.1.4.10) method, which is a blocking call; so this asynchronous method
	// is used to provide a way for the caller to not have to block or continuously poll
	// the server.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RemoteSubscriptionWaitAsync(context.Context, *RemoteSubscriptionWaitAsyncRequest) (*RemoteSubscriptionWaitAsyncResponse, error)

	// The EvtRpcRegisterControllableOperation (Opnum 4) method obtains a CONTEXT_HANDLE_OPERATION_CONTROL
	// handle that can be used to cancel other operations.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterControllableOperation(context.Context, *RegisterControllableOperationRequest) (*RegisterControllableOperationResponse, error)

	// The EvtRpcRegisterLogQuery (Opnum 5) method is used to query one or more channels.
	// It can also be used to query a specific file. Actual retrieval of events is done
	// by subsequent calls to the EvtRpcQueryNext (section 3.1.4.13) method.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RegisterLogQuery(context.Context, *RegisterLogQueryRequest) (*RegisterLogQueryResponse, error)

	// The EvtRpcClearLog (Opnum 6) method instructs the server to clear all the events
	// in a live channel, and optionally, to create a backup event log before the clear
	// takes place.
	//
	// Return Values: The method returns 0 (ERROR_SUCCESS) on success; otherwise, it MUST
	// return an implementation-specific nonzero value as specified in [MS-ERREF].
	//
	// The server does not validate the control handle passed to EvtRpcClearLog and it SHOULD
	// assume that this parameter is always valid when the method is invoked.
	ClearLog(context.Context, *ClearLogRequest) (*ClearLogResponse, error)

	// The EvtRpcExportLog (Opnum 7) method instructs the server to create a backup event
	// log at a specified file name.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	//
	// The server does not validate the control handle passed to EvtRpcExportLog, and it
	// SHOULD assume that this parameter is always valid when the method is invoked.
	ExportLog(context.Context, *ExportLogRequest) (*ExportLogResponse, error)

	// The EvtRpcLocalizeExportLog (Opnum 8) method is used by a client to add localized
	// information to a previously created backup event log, because the backup event log
	// does not contain the localized strings for event descriptions. An example of how
	// this can be useful is if a backup event log needs to be copied to other computers
	// so that support personnel on those other computers can access it; if this method
	// has been called, such support personnel can access or view the localized backup event
	// log, which will then contain events with localized strings. Note that a discussion
	// of tools by which administrators or support personnel can work with localized backup
	// event log files in scenarios such as this is out of scope with respect to this protocol
	// specification.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an error value as specified in the processing rules in this section.<33>
	// Callers SHOULD treat all return values other than ERROR_SUCCESS equally and not alter
	// their behavior based on any specific error values.
	//
	// The server does not validate the control handle passed to EvtRpcLocalizeExportLog,
	// and it SHOULD assume that this parameter is always valid when the method is invoked.
	LocalizeExportLog(context.Context, *LocalizeExportLogRequest) (*LocalizeExportLogResponse, error)

	// The EvtRpcMessageRender (Opnum 9) method is used by a client to get localized descriptive
	// strings for an event.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if maxSizeString is too
	// small to hold the result string. In that case, neededSizeString MUST be set to the
	// necessary size. Otherwise, the method MUST return a different implementation-specific
	// nonzero value as specified in [MS-ERREF].
	MessageRender(context.Context, *MessageRenderRequest) (*MessageRenderResponse, error)

	// The EvtRpcMessageRenderDefault (Opnum 10) method is used by a client to get localized
	// strings for common values of opcodes, tasks, or keywords, as specified in section
	// 3.1.4.31.
	//
	// Return Values:  The method MUST return the following value on success.
	//
	// ERROR_SUCCESS (0x00000000)
	//
	// The method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if maxSizeString is
	// too small to hold the result string. In that case, neededSizeString MUST be set to
	// the necessary size.
	//
	// Otherwise, the method MUST return a different implementation-specific nonzero value
	// as specified in [MS-ERREF].
	//
	// This method is the same as the EvtRpcMessageRender (section 3.1.4.31) method, except
	// that this method always uses the server's default strings (default strings come from
	// the server's default publisher, so a publisher handle is not required), whereas the
	// EvtRpcMessageRender (section 3.1.4.31) method uses only the default strings in the
	// case of level, task, opcode, and keyword values that fall in certain ranges. Therefore
	// it takes only 6 possible format flags. The server MUST fail the method with ERROR_INVALID_PARAMETER
	// (0x00000057) for any other flags than the 6 values given in the flags table.
	MessageRenderDefault(context.Context, *MessageRenderDefaultRequest) (*MessageRenderDefaultResponse, error)

	// The EvtRpcQueryNext (Opnum 11) method is used by a client to get the next batch of
	// records from a query result set.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_TIMEOUT (0x000005bf) if no records are found within the
	// time-out period. The method MUST return ERROR_NO_MORE_ITEMS (0x00000103) once the
	// query has finished going through all the log(s); otherwise, it MUST return a different
	// implementation-specific nonzero value as specified in [MS-ERREF].
	QueryNext(context.Context, *QueryNextRequest) (*QueryNextResponse, error)

	// The EvtRpcQuerySeek (Opnum 12) method is used by a client to move a query cursor
	// within a result set.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	QuerySeek(context.Context, *QuerySeekRequest) (*QuerySeekResponse, error)

	// The EvtRpcClose (Opnum 13) method is used by a client to close context handles that
	// are opened by other methods in this protocol.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	Close(context.Context, *CloseRequest) (*CloseResponse, error)

	// The EvtRpcCancel (Opnum 14) method is used by a client to cancel another method.
	// This can be used to terminate long-running methods gracefully. Methods that can be
	// canceled include the subscription and query functions, and other functions that take
	// a CONTEXT_HANDLE_OPERATION_CONTROL argument.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	Cancel(context.Context, *CancelRequest) (*CancelResponse, error)

	// The EvtRpcAssertConfig (Opnum 15) method indicates to the server that the publisher
	// or channel configuration has been updated.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	AssertConfig(context.Context, *AssertConfigRequest) (*AssertConfigResponse, error)

	// The EvtRpcRetractConfig (Opnum 16) method indicates to the server that the publisher
	// or channel is to be removed.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	RetractConfig(context.Context, *RetractConfigRequest) (*RetractConfigResponse, error)

	// The EvtRpcOpenLogHandle (Opnum 17) method is used by a client to get information
	// about a channel or a backup event log.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	OpenLog(context.Context, *OpenLogRequest) (*OpenLogResponse, error)

	// The EvtRpcGetLogFileInfo (Opnum 18) method is used by a client to get information
	// about a live channel or a backup event log.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success. The
	// method MUST return ERROR_INSUFFICIENT_BUFFER (0x0000007A) if the buffer is too small;
	// otherwise, it MUST return a different implementation-specific nonzero value as specified
	// in [MS-ERREF].
	GetLogFileInfo(context.Context, *GetLogFileInfoRequest) (*GetLogFileInfoResponse, error)

	// The EvtRpcGetChannelList (Opnum 19) method is used to enumerate the set of available
	// channels.
	//
	// Return Values:  The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetChannelList(context.Context, *GetChannelListRequest) (*GetChannelListResponse, error)

	// The EvtRpcGetChannelConfig (opnum 20) method is used by a client to get the configuration
	// for a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetChannelConfig(context.Context, *GetChannelConfigRequest) (*GetChannelConfigResponse, error)

	// The EvtRpcPutChannelConfig (Opnum 21) method is used by a client to update the configuration
	// for a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].<42>
	PutChannelConfig(context.Context, *PutChannelConfigRequest) (*PutChannelConfigResponse, error)

	// The EvtRpcGetPublisherList (Opnum 22) method is used by a client to get the list
	// of publishers.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherList(context.Context, *GetPublisherListRequest) (*GetPublisherListResponse, error)

	// The EvtRpcGetPublisherListForChannel (Opnum 23) method is used by a client to get
	// the list of publishers that write events to a particular channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherListForChannel(context.Context, *GetPublisherListForChannelRequest) (*GetPublisherListForChannelResponse, error)

	// The EvtRpcGetPublisherMetadata (Opnum 24) method is used by a client to open a handle
	// to publisher metadata. It also gets some initial information from the metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherMetadata(context.Context, *GetPublisherMetadataRequest) (*GetPublisherMetadataResponse, error)

	// The EvtRpcGetPublisherResourceMetadata (Opnum 25) method obtains information from
	// the publisher metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetPublisherResourceMetadata(context.Context, *GetPublisherResourceMetadataRequest) (*GetPublisherResourceMetadataResponse, error)

	// The EvtRpcGetEventMetadataEnum (Opnum 26) method obtains a handle for enumerating
	// a publisher's event metadata.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetEventMetadataEnum(context.Context, *GetEventMetadataEnumRequest) (*GetEventMetadataEnumResponse, error)

	// The EvtRpcGetNextEventMetadata (Opnum 27) method gets details about a possible event
	// and also returns the next event metadata in the enumeration. It is used to enumerate
	// through the event definitions for the publisher associated with the handle. The enumeration
	// is in the forward direction only, and there is no reset functionality.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetNextEventMetadata(context.Context, *GetNextEventMetadataRequest) (*GetNextEventMetadataResponse, error)

	// The EvtRpcGetClassicLogDisplayName (Opnum 28) method obtains a descriptive name for
	// a channel.
	//
	// Return Values: The method MUST return ERROR_SUCCESS (0x00000000) on success; otherwise,
	// it MUST return an implementation-specific nonzero value as specified in [MS-ERREF].
	GetClassicLogDisplayName(context.Context, *GetClassicLogDisplayNameRequest) (*GetClassicLogDisplayNameResponse, error)
}

IEventService server interface.

type ExportLogRequest 

type ExportLogRequest struct {
	// control: A handle to an operation control object. This parameter is an RPC context
	// handle, as specified in [C706] Context Handles.
	Control *OperationControl `idl:"name:control" json:"control"`
	// channelPath: A pointer to a string that contains the channel name (for a live event
	// log) or file path (for an existing backup event log) to be used to create a backup
	// event log.
	ChannelPath string `idl:"name:channelPath;string;pointer:unique" json:"channel_path"`
	// query: A pointer to a string that contains a query that specifies events to be included
	// in the backup event log.
	Query string `idl:"name:query;string" json:"query"`
	// backupPath: A pointer to a string that contains the path of the file for the backup
	// event logs to be created.
	BackupPath string `idl:"name:backupPath;string" json:"backup_path"`
	// flags: The client MUST set the flags parameter to one of the following values.
	//
	//	+--------------------------------+---------------------------------------------+
	//	|                                |                                             |
	//	|             VALUE              |                   MEANING                   |
	//	|                                |                                             |
	//	+--------------------------------+---------------------------------------------+
	//	+--------------------------------+---------------------------------------------+
	//	| EvtQueryChannelPath 0x00000001 | Channel parameter specifies a channel name. |
	//	+--------------------------------+---------------------------------------------+
	//	| EvtQueryFilePath 0x00000002    | Channel parameter specifies a file name.    |
	//	+--------------------------------+---------------------------------------------+
	//
	// In addition, the client MAY set the following value in the flags parameter:
	//
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	|                                        |                                                                                  |
	//	|                 VALUE                  |                                     MEANING                                      |
	//	|                                        |                                                                                  |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtQueryTolerateQueryErrors 0x00001000 | The query MUST succeed even if not all the channels or backup event logs         |
	//	|                                        | that are specified in the query are present, or if the channelPath parameter     |
	//	|                                        | specifies channels that do not exist.                                            |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

ExportLogRequest structure represents the EvtRpcExportLog operation request

func (*ExportLogRequest) MarshalNDR 

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

func (*ExportLogRequest) UnmarshalNDR 

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

type ExportLogResponse 

type ExportLogResponse struct {
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to a nonzero value if the error is related to parsing the query. In addition,
	// the server MAY set the suberror fields to nonzero values for other types of errors.
	// All nonzero values MUST be treated the same. If the method succeeds, the server MUST
	// set all of the values in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcExportLog return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

ExportLogResponse structure represents the EvtRpcExportLog operation response

func (*ExportLogResponse) MarshalNDR 

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

func (*ExportLogResponse) UnmarshalNDR 

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

type GUIDArray 

type GUIDArray struct {
	// count:  A 32-bit unsigned integer that contains the number of GUIDs pointed to by
	// ptr.
	Count uint32 `idl:"name:count" json:"count"`
	// ptr:   A pointer to an array of GUIDs.
	Array []*dtyp.GUID `idl:"name:ptr;size_is:(count)" json:"array"`
}

GUIDArray structure represents GuidArray RPC structure.

The GuidArray structure is defined as follows.

func (*GUIDArray) MarshalNDR 

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

func (*GUIDArray) UnmarshalNDR 

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

type GetChannelConfigRequest 

type GetChannelConfigRequest struct {
	// channelPath: A pointer to a string that contains the name of a channel for which
	// the information is needed.
	ChannelPath string `idl:"name:channelPath;string" json:"channel_path"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<38>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetChannelConfigRequest structure represents the EvtRpcGetChannelConfig operation request

func (*GetChannelConfigRequest) MarshalNDR 

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

func (*GetChannelConfigRequest) UnmarshalNDR 

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

type GetChannelConfigResponse 

type GetChannelConfigResponse struct {
	// props: A pointer to an EvtRpcVariantList structure to be filled with channel properties,
	// as defined in the following table.
	//
	// Note  The index column in the following table is the array index, not the actual
	// field of the EvtRpcVariantList structure. The returned data is an array of EvtRpcVariantList
	// for which the index value is used to identify the elements in the array. For example,
	// index 0 means the first element of the returned array.
	//
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|       |                          |                                                                                  |
	//	| INDEX |           TYPE           |                                     MEANING                                      |
	//	|       |                          |                                                                                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     0 | EvtRpcVarTypeBoolean     | Enabled. If true, the channel can accept new events. If false, any attempts to   |
	//	|       |                          | write events into this channel are automatically dropped.                        |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     1 | EvtRpcVarTypeUInt32      | Channel Isolation. It defines the default access permissions for the channel.    |
	//	|       |                          | Three values are allowed: 0: Application. 1: System. 2: Custom. The default      |
	//	|       |                          | isolation is Application. The default permissions for Application are (shown     |
	//	|       |                          | using SDDL): L"O:BAG:SYD:" L"(A;;0xf0007;;;SY)" // local system (read,           |
	//	|       |                          | write, clear) L"(A;;0x7;;;BA)" // built-in admins (read, write, clear)           |
	//	|       |                          | L"(A;;0x7;;;SO)" // server operators (read, write, clear) L"(A;;0x3;;;IU)"       |
	//	|       |                          | // INTERACTIVE LOGON (read, write) L"(A;;0x3;;;SU)" // SERVICES LOGON (read,     |
	//	|       |                          | write) L"(A;;0x3;;;S-1-5-3)" // BATCH LOGON (read, write) L"(A;;0x3;;;S-1-5-33)" |
	//	|       |                          | // write restricted service (read,write) L"(A;;0x1;;;S-1-5-32-573)"; //          |
	//	|       |                          | event log readers (read) The default permissions for System are (shown           |
	//	|       |                          | using SDDL): L"O:BAG:SYD:" L"(A;;0xf0007;;;SY)" // local system (read,           |
	//	|       |                          | write, clear) L"(A;;0x7;;;BA)" // built-in admins (read, write, clear)           |
	//	|       |                          | L"(A;;0x3;;;BO)" // backup operators (read, write) L"(A;;0x5;;;SO)" //           |
	//	|       |                          | server operators (read, clear) L"(A;;0x1;;;IU)" // INTERACTIVE LOGON (read)      |
	//	|       |                          | L"(A;;0x3;;;SU)" // SERVICES LOGON (read, write) L"(A;;0x1;;;S-1-5-3)" //        |
	//	|       |                          | BATCH LOGON (read) L"(A;;0x2;;;S-1-5-33)" // write restricted service (write)    |
	//	|       |                          | L"(A;;0x1;;;S-1-5-32-573)"; // event log readers (read) When the Custom value is |
	//	|       |                          | used, the Access property will contain the defined SDDL.                         |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     2 | EvtRpcVarTypeUInt32      | Channel type. One of four values: 0: Admin 1: Operational 2: Analytic 3: Debug   |
	//	|       |                          | For more information, see [MSDN-EVTLGCHWINEVTLG].                                |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     3 | EvtRpcVarTypeString      | OwningPublisher. Name of the publisher that defines and registers the channel    |
	//	|       |                          | with the system. For more information on how the server reacts to changes of     |
	//	|       |                          | this property, see section 3.1.4.22.                                             |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     4 | EvtRpcVarTypeBoolean     | ClassicEventlog. If true, the channel represents an event log created according  |
	//	|       |                          | to the EventLog Remoting Protocol, not this protocol (EventLog Remoting Protocol |
	//	|       |                          | Version 6.0). The server maintains two channel tables: one for the EventLog      |
	//	|       |                          | Remoting Protocol Version 6.0 and one for the legacy EventLog Remoting Protocol. |
	//	|       |                          | The table for the legacy EventLog Remoting Protocol is called "log table". For   |
	//	|       |                          | more information on the legacy "log table", see [MS-EVEN]. Any channel coming    |
	//	|       |                          | from the new "channel table" gets the value as false, any channel name that is   |
	//	|       |                          | in the legacy "log table" gets the value as true.                                |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     5 | EvtRpcVarTypeString      | Access. A Security Descriptor Description Language (SDDL) string, as specified   |
	//	|       |                          | in [MS-DTYP], that represents access permissions to the channels. If the         |
	//	|       |                          | isolation attribute is set to Application or System, the access descriptor       |
	//	|       |                          | controls read access to the file (the write permissions are ignored). If the     |
	//	|       |                          | isolation attribute is set to Custom, the access descriptor controls write       |
	//	|       |                          | access to the channel and read access to the file.                               |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     6 | EvtRpcVarTypeBoolean     | Retention. If set to true, events can never be overwritten unless explicitly     |
	//	|       |                          | cleared. If set to false, events are overwritten as needed when the event log is |
	//	|       |                          | full.                                                                            |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     7 | EvtRpcVarTypeBoolean     | AutoBackup. When set to true, the event log file associated with the channel is  |
	//	|       |                          | closed as soon as it reaches the maximum size specified by the MaxSize property, |
	//	|       |                          | and a new file is opened to accept new events. If the new file reaches maximum   |
	//	|       |                          | size, another new file will be generated and the previous new file will be       |
	//	|       |                          | backed up. The events in backed up files cannot be queried from this channel in  |
	//	|       |                          | the server unless the client specifies the backup log file names in a separate   |
	//	|       |                          | query.                                                                           |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     8 | EvtRpcVarTypeUInt64      | MaxSize. The value that indicates at which point the size (in bytes) of the      |
	//	|       |                          | event log file stops increasing. When the size is greater than or equal to this  |
	//	|       |                          | value, the file growth stops.                                                    |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     9 | EvtRpcVarTypeString      | LogFilePath. File path to the event log file for the channel. The path is saved  |
	//	|       |                          | in the channel config and read out by the server when client requests it.        |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    10 | EvtRpcVarTypeUInt32      | Level. Events with a level property less than or equal to this specified value   |
	//	|       |                          | are logged to the channel.                                                       |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    11 | EvtRpcVarTypeUInt64      | Keywords. Events with a keyword bit contained in the Keywords bitmask set are    |
	//	|       |                          | logged to the channel.                                                           |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    12 | EvtRpcVarTypeGuid        | ControlGuid. A GUID value. The client SHOULD ignore this value.                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    13 | EvtRpcVarTypeUInt64      | BufferSize. Size of the events buffer (in kilobytes) used for asynchronous event |
	//	|       |                          | delivery. This property is for providing events. Typically the events generated  |
	//	|       |                          | by a publisher are first written to memory buffers on the server. Once the       |
	//	|       |                          | buffer used is full, that buffer is written to a disk file. The BufferSize is    |
	//	|       |                          | used to specify the size of the buffer. The server allocates buffers according   |
	//	|       |                          | to the BufferSize value. The number of buffers the server can allocate is        |
	//	|       |                          | controlled by the MinBuffers and MaxBuffers properties. The server's specific    |
	//	|       |                          | implementation can allocate any number of buffers between MinBuffers and         |
	//	|       |                          | MaxBuffers.                                                                      |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    14 | EvtRpcVarTypeUInt32      | MinBuffers. The minimum number of buffers used for asynchronous event delivery.  |
	//	|       |                          | For more information, see the preceding BufferSize information.                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    15 | EvtRpcVarTypeUInt32      | MaxBuffers. The maximum number of buffers used for asynchronous event delivery.  |
	//	|       |                          | For more information, see the preceding BufferSize information.                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    16 | EvtRpcVarTypeUInt32      | Latency. The number of seconds of inactivity (if events are delivered            |
	//	|       |                          | asynchronously and no new events are arriving) after which the event buffers     |
	//	|       |                          | MUST be flushed to the server. As specified in the description for BufferSize    |
	//	|       |                          | property, the server keeps a number of buffers when writing events. If the       |
	//	|       |                          | buffers are full, the server writes the buffers to disk file. However, if a      |
	//	|       |                          | certain amount of time elapses and the buffers are still not full, the server    |
	//	|       |                          | SHOULD write the buffers to disk. That certain amount of time is the latency     |
	//	|       |                          | property.                                                                        |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    17 | EvtRpcVarTypeUInt32      | ClockType. One of two values: 0: SystemTime. Use the system time. When set       |
	//	|       |                          | to this value, the server uses the system time type (which is low-resolution     |
	//	|       |                          | on most platforms) for a time stamp field of any event it writes into this       |
	//	|       |                          | channel. 1: Query Performance Counter. The server uses a high-resolution time    |
	//	|       |                          | type for the time stamp field of any event it writes into this channel. Note The |
	//	|       |                          | timestamp is simply written into the event without any special handling. Which   |
	//	|       |                          | is to say, the server behavior does not change if a channel's Clock type is      |
	//	|       |                          | SystemTime or Query Performance Counter.                                         |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    18 | EvtRpcVarTypeUInt32      | SIDType. One of two values: 0: The events written by the server to this channel  |
	//	|       |                          | will not include the publisher's SID. 1: The events written by the server to     |
	//	|       |                          | this channel will include the publisher's SID.                                   |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    19 | EvtRpcVarTypeStringArray | PublisherList. List of publishers that can raise events into the channel. This   |
	//	|       |                          | returns the same list as is returned by the EvtRpcGetPublisherList method, as    |
	//	|       |                          | specified in section 3.1.4.24.                                                   |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    20 | EvtRpcVarTypeUint32      | FileMax. Maximum number of log files associated with an analytic or debug        |
	//	|       |                          | channel. When the number of logs reaches the specified maximum, the system       |
	//	|       |                          | begins to overwrite the logs, beginning with the oldest. A FileMax value of 0 or |
	//	|       |                          | 1 indicates that only one file is associated with this channel. A FileMax of 0   |
	//	|       |                          | is default.<39>                                                                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	Properties *VariantList `idl:"name:props" json:"properties"`
	// Return: The EvtRpcGetChannelConfig return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetChannelConfigResponse structure represents the EvtRpcGetChannelConfig operation response

func (*GetChannelConfigResponse) MarshalNDR 

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

func (*GetChannelConfigResponse) UnmarshalNDR 

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

type GetChannelListRequest 

type GetChannelListRequest struct {
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<37>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetChannelListRequest structure represents the EvtRpcGetChannelList operation request

func (*GetChannelListRequest) MarshalNDR 

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

func (*GetChannelListRequest) UnmarshalNDR 

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

type GetChannelListResponse 

type GetChannelListResponse struct {
	// numChannelPaths:  A pointer to a 32-bit unsigned integer that contains the number
	// of channel names.
	ChannelPathsLength uint32 `idl:"name:numChannelPaths" json:"channel_paths_length"`
	// channelPaths: A pointer to an array of strings that contain all the channel names.
	ChannelPaths []string `idl:"name:channelPaths;size_is:(, numChannelPaths);string" json:"channel_paths"`
	// Return: The EvtRpcGetChannelList return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetChannelListResponse structure represents the EvtRpcGetChannelList operation response

func (*GetChannelListResponse) MarshalNDR 

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

func (*GetChannelListResponse) UnmarshalNDR 

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

type GetClassicLogDisplayNameRequest 

type GetClassicLogDisplayNameRequest struct {
	// logName: The channel name for which the descriptive name is needed.
	LogName string `idl:"name:logName;string" json:"log_name"`
	// locale: The locale, as specified in [MS-GPSI] Appendix A, to be used for localizing
	// the log.
	Locale uint32 `idl:"name:locale" json:"locale"`
	// flags: A 32-bit unsigned integer that MUST be set to one of the following values:
	//
	//	+-------+----------------------------------------------------------------------------------+
	//	|       |                                                                                  |
	//	| VALUE |                                     MEANING                                      |
	//	|       |                                                                                  |
	//	+-------+----------------------------------------------------------------------------------+
	//	+-------+----------------------------------------------------------------------------------+
	//	| 0x0   | If a locale is specified, that locale will be used and no fallback locale will   |
	//	|       | be attempted if the locale is not present.                                       |
	//	+-------+----------------------------------------------------------------------------------+
	//	| 0x100 | If set, instructs the server to pick the best locale, if the locale specified by |
	//	|       | the locale parameter is not present. Please see the following processing rules   |
	//	|       | for more information on how the server picks the best locale.                    |
	//	+-------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetClassicLogDisplayNameRequest structure represents the EvtRpcGetClassicLogDisplayName operation request

func (*GetClassicLogDisplayNameRequest) MarshalNDR 

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

func (*GetClassicLogDisplayNameRequest) UnmarshalNDR 

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

type GetClassicLogDisplayNameResponse 

type GetClassicLogDisplayNameResponse struct {
	// displayName: Returned display name.
	DisplayName string `idl:"name:displayName" json:"display_name"`
	// Return: The EvtRpcGetClassicLogDisplayName return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetClassicLogDisplayNameResponse structure represents the EvtRpcGetClassicLogDisplayName operation response

func (*GetClassicLogDisplayNameResponse) MarshalNDR 

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

func (*GetClassicLogDisplayNameResponse) UnmarshalNDR 

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

type GetEventMetadataEnumRequest 

type GetEventMetadataEnumRequest struct {
	// pubMetadata: This parameter is an RPC context handle, as specified in [C706], Context
	// Handles. For information on handle security and authentication considerations, see
	// sections 2.2.20 and 5.1.
	PublisherMetadata *PublisherMetadata `idl:"name:pubMetadata" json:"publisher_metadata"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<54>
	Flags uint32 `idl:"name:flags" json:"flags"`
	// reservedForFilter: A pointer to a null string that MUST be ignored on receipt.
	ReservedForFilter string `idl:"name:reservedForFilter;string;pointer:unique" json:"reserved_for_filter"`
}

GetEventMetadataEnumRequest structure represents the EvtRpcGetEventMetadataEnum operation request

func (*GetEventMetadataEnumRequest) MarshalNDR 

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

func (*GetEventMetadataEnumRequest) UnmarshalNDR 

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

type GetEventMetadataEnumResponse 

type GetEventMetadataEnumResponse struct {
	// eventMetaDataEnum: A pointer to an event numeration handle. This parameter is an
	// RPC context handle, as specified in [C706], Context Handles.
	EventMetadataEnum *EventMetadataEnum `idl:"name:eventMetaDataEnum" json:"event_metadata_enum"`
	// Return: The EvtRpcGetEventMetadataEnum return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetEventMetadataEnumResponse structure represents the EvtRpcGetEventMetadataEnum operation response

func (*GetEventMetadataEnumResponse) MarshalNDR 

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

func (*GetEventMetadataEnumResponse) UnmarshalNDR 

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

type GetLogFileInfoRequest 

type GetLogFileInfoRequest struct {
	// logHandle: A handle to an event log. This parameter is an RPC context handle, as
	// specified in [C706], Context Handles. For more information about the server-side
	// object that maps to this handle, see section 3.1.4.19.
	Log *Log `idl:"name:logHandle" json:"log"`
	// propertyId: A 32-bit unsigned integer that indicates what log file property (as specified
	// in section 3.1.1.6) needs to be retrieved.
	//
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	|                                     |                                                                                  |
	//	|                VALUE                |                                     MEANING                                      |
	//	|                                     |                                                                                  |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogCreationTime 0x00000000       | A FILETIME containing the creation time of the file. This is the creation time   |
	//	|                                     | of a log file associated with the channel or the creation time of the backup     |
	//	|                                     | event log file in the server's file system.                                      |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogLastAccessTime 0x00000001     | A FILETIME containing the last access time of the file. This is the last access  |
	//	|                                     | time of a log file associated with the channel or the last access time of the    |
	//	|                                     | backup event log file in the server's file system.                               |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogLastWriteTime 0x00000002      | A FILETIME containing the last write time of the file. This is the last written  |
	//	|                                     | time of a log file associated with the channel or the last written time of the   |
	//	|                                     | backup event log file in the server's file system.                               |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogFileSize 0x00000003           | An unsigned 64-bit integer containing the size of the file. This is the file     |
	//	|                                     | size of a log file associated with the channel or the file size of the backup    |
	//	|                                     | event log file in the server's file system.                                      |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogAttributes 0x00000004         | An unsigned 32-bit integer containing the attributes of the file. The attributes |
	//	|                                     | are implementation-specific, and clients MUST<23> treat all values equally.      |
	//	|                                     | The attributes are tracked by the server's file system and SHOULD be able to be  |
	//	|                                     | retrieved from the file system.                                                  |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogNumberOfLogRecords 0x00000005 | An unsigned 64-bit integer containing the number of records in the file. See the |
	//	|                                     | following processing rules for how the server gets this value.                   |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogOldestRecordNumber 0x00000006 | An unsigned 64-bit integer containing the oldest record number in the file. See  |
	//	|                                     | the following processing rules for how the server gets this value.               |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtLogFull 0x00000007               | A BOOLEAN value; MUST be true if the log is full, and MUST be false otherwise.   |
	//	|                                     | See the following processing rules for how the server gets this value.           |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	PropertyID uint32 `idl:"name:propertyId" json:"property_id"`
	// propertyValueBufferSize: A 32-bit unsigned integer that contains the length of caller's
	// buffer in bytes.
	PropertyValueBufferSize uint32 `idl:"name:propertyValueBufferSize" json:"property_value_buffer_size"`
}

GetLogFileInfoRequest structure represents the EvtRpcGetLogFileInfo operation request

func (*GetLogFileInfoRequest) MarshalNDR 

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

func (*GetLogFileInfoRequest) UnmarshalNDR 

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

type GetLogFileInfoResponse 

type GetLogFileInfoResponse struct {
	// propertyValueBuffer: A byte-array that contains the buffer for returned data.
	PropertyValueBuffer []byte `idl:"name:propertyValueBuffer;size_is:(propertyValueBufferSize)" json:"property_value_buffer"`
	// propertyValueBufferLength: A pointer to a 32-bit unsigned integer that contains the
	// size in bytes of the returned data.
	PropertyValueBufferLength uint32 `idl:"name:propertyValueBufferLength" json:"property_value_buffer_length"`
	// Return: The EvtRpcGetLogFileInfo return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetLogFileInfoResponse structure represents the EvtRpcGetLogFileInfo operation response

func (*GetLogFileInfoResponse) MarshalNDR 

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

func (*GetLogFileInfoResponse) UnmarshalNDR 

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

type GetNextEventMetadataRequest 

type GetNextEventMetadataRequest struct {
	// eventMetaDataEnum: A handle to an event metadata enumerator. This parameter is an
	// RPC context handle, as specified in [C706], Context Handles. For information on handle
	// security and authentication considerations, see sections 2.2.20 and 5.1. This is
	// the value which comes from the return parameter eventMetaDataEnum of function EvtRpcGetEventMetadataEnum
	// (as specified in 3.1.4.27).
	EventMetadataEnum *EventMetadataEnum `idl:"name:eventMetaDataEnum" json:"event_metadata_enum"`
	// flags: A 32-bit unsigned integer that MUST be set to 0x00000000 when sent and MAY
	// be ignored on receipt.<56>
	Flags uint32 `idl:"name:flags" json:"flags"`
	// numRequested: A 32-bit unsigned integer that contains the number of events for which
	// the properties are needed.
	RequestedLength uint32 `idl:"name:numRequested" json:"requested_length"`
}

GetNextEventMetadataRequest structure represents the EvtRpcGetNextEventMetadata operation request

func (*GetNextEventMetadataRequest) MarshalNDR 

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

func (*GetNextEventMetadataRequest) UnmarshalNDR 

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

type GetNextEventMetadataResponse 

type GetNextEventMetadataResponse struct {
	// numReturned: A pointer to a 32-bit unsigned integer that contains the number of events
	// for which the properties are retrieved.
	ReturnedLength uint32 `idl:"name:numReturned" json:"returned_length"`
	// eventMetadataInstances: A pointer to an array of EvtRpcVariantList (section 2.2.9)
	// structures.
	EventMetadataInstances []*VariantList `idl:"name:eventMetadataInstances;size_is:(, numReturned)" json:"event_metadata_instances"`
	// Return: The EvtRpcGetNextEventMetadata return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetNextEventMetadataResponse structure represents the EvtRpcGetNextEventMetadata operation response

func (*GetNextEventMetadataResponse) MarshalNDR 

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

func (*GetNextEventMetadataResponse) UnmarshalNDR 

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

type GetPublisherListForChannelRequest 

type GetPublisherListForChannelRequest struct {
	// channelName:  A pointer to a string that contains the name of the channel for which
	// the publisher list is needed.
	ChannelName string `idl:"name:channelName" json:"channel_name"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<47>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetPublisherListForChannelRequest structure represents the EvtRpcGetPublisherListForChannel operation request

func (*GetPublisherListForChannelRequest) MarshalNDR 

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

func (*GetPublisherListForChannelRequest) UnmarshalNDR 

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

type GetPublisherListForChannelResponse 

type GetPublisherListForChannelResponse struct {
	// numPublisherIds: A pointer to a 32-bit unsigned integer that contains the number
	// of publishers that are registered and that can write to the log.
	PublisherIDsLength uint32 `idl:"name:numPublisherIds" json:"publisher_ids_length"`
	// publisherIds: A pointer to an array of strings that contain publisher names.
	PublisherIDs []string `idl:"name:publisherIds;size_is:(, numPublisherIds);string" json:"publisher_ids"`
	// Return: The EvtRpcGetPublisherListForChannel return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetPublisherListForChannelResponse structure represents the EvtRpcGetPublisherListForChannel operation response

func (*GetPublisherListForChannelResponse) MarshalNDR 

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

func (*GetPublisherListForChannelResponse) UnmarshalNDR 

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

type GetPublisherListRequest 

type GetPublisherListRequest struct {
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<45>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetPublisherListRequest structure represents the EvtRpcGetPublisherList operation request

func (*GetPublisherListRequest) MarshalNDR 

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

func (*GetPublisherListRequest) UnmarshalNDR 

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

type GetPublisherListResponse 

type GetPublisherListResponse struct {
	// numPublisherIds: A pointer to a 32-bit unsigned integer that contains the number
	// of publisher names.
	PublisherIDsLength uint32 `idl:"name:numPublisherIds" json:"publisher_ids_length"`
	// publisherIds: A pointer to an array of strings that contain publisher names.
	PublisherIDs []string `idl:"name:publisherIds;size_is:(, numPublisherIds);string" json:"publisher_ids"`
	// Return: The EvtRpcGetPublisherList return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetPublisherListResponse structure represents the EvtRpcGetPublisherList operation response

func (*GetPublisherListResponse) MarshalNDR 

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

func (*GetPublisherListResponse) UnmarshalNDR 

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

type GetPublisherMetadataRequest 

type GetPublisherMetadataRequest struct {
	// publisherId: A pointer to a string that contains the publisher for which information
	// is needed.
	PublisherID string `idl:"name:publisherId;string;pointer:unique" json:"publisher_id"`
	// logFilePath: A pointer to a null string that MUST be ignored on receipt.
	LogFilePath string `idl:"name:logFilePath;string;pointer:unique" json:"log_file_path"`
	// locale: A Locale value, as specified in [MS-GPSI]. This is used later if the pubMetadata
	// handle is used for rendering.
	Locale uint32 `idl:"name:locale" json:"locale"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<48>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetPublisherMetadataRequest structure represents the EvtRpcGetPublisherMetadata operation request

func (*GetPublisherMetadataRequest) MarshalNDR 

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

func (*GetPublisherMetadataRequest) UnmarshalNDR 

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

type GetPublisherMetadataResponse 

type GetPublisherMetadataResponse struct {
	// pubMetadataProps: A pointer to an EvtRpcVariantList (section 2.2.9) structure containing
	// publisher properties.
	PublisherMetadataProperties *VariantList `idl:"name:pubMetadataProps" json:"publisher_metadata_properties"`
	// pubMetadata: A pointer to a publisher handle. This parameter is an RPC context handle,
	// as specified in [C706], Context Handles. For information on handle security and authentication
	// considerations, see sections 2.2.20 and 5.1.
	PublisherMetadata *PublisherMetadata `idl:"name:pubMetadata" json:"publisher_metadata"`
	// Return: The EvtRpcGetPublisherMetadata return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetPublisherMetadataResponse structure represents the EvtRpcGetPublisherMetadata operation response

func (*GetPublisherMetadataResponse) MarshalNDR 

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

func (*GetPublisherMetadataResponse) UnmarshalNDR 

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

type GetPublisherResourceMetadataRequest 

type GetPublisherResourceMetadataRequest struct {
	// handle: A handle to an event log. This handle is returned by the EvtRpcGetPublisherMetadata
	// (Opnum 24) method. This parameter is an RPC context handle, as specified in [C706],
	// Context Handles.
	Handle *PublisherMetadata `idl:"name:handle" json:"handle"`
	// propertyId: Type of information as specified in the following table.
	//
	//	+------------+--------------------------+
	//	|            |                          |
	//	|   VALUE    |         MEANING          |
	//	|            |                          |
	//	+------------+--------------------------+
	//	+------------+--------------------------+
	//	| 0x00000004 | Publisher help link.     |
	//	+------------+--------------------------+
	//	| 0x00000005 | Publisher friendly name. |
	//	+------------+--------------------------+
	//	| 0x0000000C | Level information.       |
	//	+------------+--------------------------+
	//	| 0x00000010 | Task information.        |
	//	+------------+--------------------------+
	//	| 0x00000015 | Opcode information.      |
	//	+------------+--------------------------+
	//	| 0x00000019 | Keyword information.     |
	//	+------------+--------------------------+
	PropertyID uint32 `idl:"name:propertyId" json:"property_id"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<50>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

GetPublisherResourceMetadataRequest structure represents the EvtRpcGetPublisherResourceMetadata operation request

func (*GetPublisherResourceMetadataRequest) MarshalNDR 

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

func (*GetPublisherResourceMetadataRequest) UnmarshalNDR 

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

type GetPublisherResourceMetadataResponse 

type GetPublisherResourceMetadataResponse struct {
	// pubMetadataProps: Pointer to an EvtRpcVariantList (section 2.2.9) structure. This
	// list MUST contain multiple entries.
	PublisherMetadataProperties *VariantList `idl:"name:pubMetadataProps" json:"publisher_metadata_properties"`
	// Return: The EvtRpcGetPublisherResourceMetadata return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

GetPublisherResourceMetadataResponse structure represents the EvtRpcGetPublisherResourceMetadata operation response

func (*GetPublisherResourceMetadataResponse) MarshalNDR 

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

func (*GetPublisherResourceMetadataResponse) UnmarshalNDR 

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

type Info 

type Info struct {
	// m_error:  A Win32 error code that contains a general operation success or failure
	// status. A value of 0x00000000 indicates success; any other value indicates failure.
	// Unless noted otherwise, all failure values MUST be treated equally.
	Error uint32 `idl:"name:m_error" json:"error"`
	// m_subErr:  MUST be zero unless specified otherwise in the method using this structure.
	// Unless noted otherwise, all nonzero values MUST be treated equally.
	SubError uint32 `idl:"name:m_subErr" json:"sub_error"`
	// m_subErrParam:   MUST be zero unless specified otherwise in the method using this
	// structure. Unless noted otherwise, all nonzero values MUST be treated equally.
	SubErrorParam uint32 `idl:"name:m_subErrParam" json:"sub_error_param"`
}

Info structure represents RpcInfo RPC structure.

The RpcInfo structure is used for certain methods that return additional information about errors.

func (*Info) MarshalNDR 

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

func (*Info) UnmarshalNDR 

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

type LocalizeExportLogRequest 

type LocalizeExportLogRequest struct {
	// control: A handle to an operation control object. This parameter MUST be an RPC context
	// handle, as specified in [C706], Context Handles.
	Control *OperationControl `idl:"name:control" json:"control"`
	// logFilePath: A pointer to a string that contains the path of the backup event log
	// to be localized.
	LogFilePath string `idl:"name:logFilePath;string" json:"log_file_path"`
	// locale: Locale, as specified in [MS-GPSI] Appendix A, to be used for localizing the
	// log.
	Locale uint32 `idl:"name:locale" json:"locale"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<31>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

LocalizeExportLogRequest structure represents the EvtRpcLocalizeExportLog operation request

func (*LocalizeExportLogRequest) MarshalNDR 

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

func (*LocalizeExportLogRequest) UnmarshalNDR 

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

type LocalizeExportLogResponse 

type LocalizeExportLogResponse struct {
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to loading localization information.
	// All nonzero values MUST be treated the same. If the method succeeds, the server MUST
	// set all of the values in the structure to zero.<32>
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcLocalizeExportLog return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

LocalizeExportLogResponse structure represents the EvtRpcLocalizeExportLog operation response

func (*LocalizeExportLogResponse) MarshalNDR 

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

func (*LocalizeExportLogResponse) UnmarshalNDR 

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

type Log 

type Log dcetypes.ContextHandle

Log structure represents PCONTEXT_HANDLE_LOG_HANDLE RPC structure.

func (*Log) ContextHandle 

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

func (*Log) MarshalNDR 

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

func (*Log) UnmarshalNDR 

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

type LogQuery 

type LogQuery dcetypes.ContextHandle

LogQuery structure represents PCONTEXT_HANDLE_LOG_QUERY RPC structure.

func (*LogQuery) ContextHandle 

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

func (*LogQuery) MarshalNDR 

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

func (*LogQuery) UnmarshalNDR 

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

type MessageRenderDefaultRequest 

type MessageRenderDefaultRequest struct {
	// sizeEventId: A 32-bit unsigned integer that contains the size in bytes of the eventId
	// field.
	SizeEventID uint32 `idl:"name:sizeEventId" json:"size_event_id"`
	// eventId: A pointer to an EVENT_DESCRIPTOR structure, as specified in [MS-DTYP] section
	// 2.3.1.
	EventID []byte `idl:"name:eventId;size_is:(sizeEventId)" json:"event_id"`
	// messageId: A 32-bit unsigned integer that specifies the required message. This is
	// an alternative to using the eventID parameter that can be used by a client application
	// that has obtained the value through some method outside those documented by this
	// protocol. The server MUST ignore this value unless the flags value is set to EvtFormatMessageId,
	// in which case the server MUST use this value to determine the required message and
	// ignore the eventID parameter.
	MessageID uint32 `idl:"name:messageId" json:"message_id"`
	// values: An array of strings to be used as substitution values for event description
	// strings. Substitution values MUST be ignored by the server except when the flags
	// are set to either EvtFormatMessageEvent or EvtFormatMessageId.
	Values *VariantList `idl:"name:values" json:"values"`
	// flags: This field MUST be set to a value from the following table, which indicates
	// the action that the server is requested to perform.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|                                    |                                                                                  |
	//	|               VALUE                |                                     MEANING                                      |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageEvent 0x00000001   | Locate the message for the event corresponding to eventId, and then insert the   |
	//	|                                    | values specified by the values parameter.                                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageLevel 0x00000002   | Extract the level field from eventId, and then return the localized name for     |
	//	|                                    | that level.                                                                      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageTask 0x00000003    | Extract the task field from eventId, and then return the localized name for that |
	//	|                                    | task.                                                                            |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageOpcode 0x00000004  | Extract the opcode field from eventId, and then return the localized name for    |
	//	|                                    | that opcode.                                                                     |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageKeyword 0x00000005 | Extract the keyword field from eventId, and then return the localized name for   |
	//	|                                    | that keyword.                                                                    |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageId 0x00000008      | Locate the message for the event corresponding to the messageId parameter, and   |
	//	|                                    | then insert the values specified by the values parameter.                        |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
	// maxSizeString: A 32-bit unsigned integer that contains the maximum size in bytes
	// allowed for the string field.
	MaxSizeString uint32 `idl:"name:maxSizeString" json:"max_size_string"`
}

MessageRenderDefaultRequest structure represents the EvtRpcMessageRenderDefault operation request

func (*MessageRenderDefaultRequest) MarshalNDR 

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

func (*MessageRenderDefaultRequest) UnmarshalNDR 

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

type MessageRenderDefaultResponse 

type MessageRenderDefaultResponse struct {
	// actualSizeString: A pointer to a 32-bit unsigned integer that contains the actual
	// size of the resulting description string returned in the string. It MUST be set to
	// the size in bytes of the string returned in the string parameter, including the NULL
	// ('\0') terminating character. If the description string cannot be retrieved, actualSizeString
	// MUST be set to zero.
	ActualSizeString uint32 `idl:"name:actualSizeString" json:"actual_size_string"`
	// neededSizeString: A pointer to a 32-bit unsigned integer that contains the size in
	// bytes of the fully instantiated description string, even if the length of the description
	// string is greater than maxSizeString. The returned value MUST be zero when the description
	// string cannot be computed by the server.
	NeededSizeString uint32 `idl:"name:neededSizeString" json:"needed_size_string"`
	// string: A buffer in which to return either a null-terminated string or multiple null-terminated
	// strings, terminated by a double NULL in the case of keywords. In the case of failure,
	// the client MUST ignore this value.
	String []byte `idl:"name:string;size_is:(, actualSizeString)" json:"string"`
	// error:  A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to loading the necessary resource.
	// All nonzero values MUST be treated the same. If the method succeeds, the server MUST
	// set all of the values in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcMessageRenderDefault return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

MessageRenderDefaultResponse structure represents the EvtRpcMessageRenderDefault operation response

func (*MessageRenderDefaultResponse) MarshalNDR 

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

func (*MessageRenderDefaultResponse) UnmarshalNDR 

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

type MessageRenderRequest 

type MessageRenderRequest struct {
	// pubCfgObj: A handle to a publisher object. This parameter is an RPC context handle,
	// as specified in [C706], Context Handles. This value comes from the return parameter
	// pubMetadata of the function EvtRpcGetPublisherMetadata (section 3.1.4.25).
	PublisherConfigObject *PublisherMetadata `idl:"name:pubCfgObj" json:"publisher_config_object"`
	// sizeEventId: A 32-bit unsigned integer that contains the size, in bytes, of the data
	// in the eventId field. The server MUST ignore this value if EvtFormatMessageId is
	// specified as the flags parameter. If EvtFormatMessageId is not specified in the flags
	// parameter, the server MUST use the sizeEventId parameter and ignore the messageId
	// parameter.
	SizeEventID uint32 `idl:"name:sizeEventId" json:"size_event_id"`
	// eventId: A pointer to an EVENT_DESCRIPTOR structure, as specified in [MS-DTYP] section
	// 2.3.1.
	EventID []byte `idl:"name:eventId;size_is:(sizeEventId)" json:"event_id"`
	// messageId: A 32-bit unsigned integer that specifies the required message. This is
	// an alternative to using the eventID parameter used by a client application that has
	// obtained the value through some method outside those documented by this protocol.
	// The server MUST ignore this value unless the flags value is set to EvtFormatMessageId;
	// in which case, the server MUST use this value to determine the required message and
	// ignore the eventID parameter.
	MessageID uint32 `idl:"name:messageId" json:"message_id"`
	// values: An array of strings used as substitution values for event description strings.
	// The number of strings submitted is determined by the number of description strings
	// contained in the event message specified by the eventID or messageId parameter.<62>
	Values *VariantList `idl:"name:values" json:"values"`
	// flags: For all options except EvtFormatMessageId, the eventId parameter is used to
	// specify an event descriptor. For the EvtFormatMessageId option, the messageId is
	// used for locating the message. This MUST be set to one of the values in the following
	// table, which indicates the action a server is requested to perform.
	//
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	|                                     |                                                                                  |
	//	|                VALUE                |                                     MEANING                                      |
	//	|                                     |                                                                                  |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageEvent 0x00000001    | Locate the message for the event that corresponds to eventID, and then insert    |
	//	|                                     | the values specified by the values parameter.                                    |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageLevel 0x00000002    | Extract the level field from eventID, and then return the localized name for     |
	//	|                                     | that level.                                                                      |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageTask 0x00000003     | Extract the task field from eventID, and then return the localized name for that |
	//	|                                     | task.                                                                            |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageOpcode 0x00000004   | Extract the opcode field from eventID, and then return the localized name for    |
	//	|                                     | that opcode.                                                                     |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageKeyword 0x00000005  | Extract the keyword field from eventID, and then return the localized name for   |
	//	|                                     | that keyword.                                                                    |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageChannel 0x00000006  | Extract the channel field from eventID, and then return the localized name for   |
	//	|                                     | that channel.                                                                    |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageProvider 0x00000007 | Return the localized name of the publisher.                                      |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtFormatMessageId 0x00000008       | Locate the message for the event corresponding to the messageId parameter, and   |
	//	|                                     | then insert the values specified by the values parameter.                        |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
	// maxSizeString: A 32-bit unsigned integer that contains the size, in bytes, of the
	// string that is provided by the caller.
	MaxSizeString uint32 `idl:"name:maxSizeString" json:"max_size_string"`
}

MessageRenderRequest structure represents the EvtRpcMessageRender operation request

func (*MessageRenderRequest) MarshalNDR 

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

func (*MessageRenderRequest) UnmarshalNDR 

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

type MessageRenderResponse 

type MessageRenderResponse struct {
	// actualSizeString: A pointer to a 32-bit unsigned integer that, on return, contains
	// the actual size, in bytes, of the resulting description (including null termination).
	ActualSizeString uint32 `idl:"name:actualSizeString" json:"actual_size_string"`
	// neededSizeString: A pointer to a 32-bit unsigned integer that, on return, contains
	// the needed size, in bytes (including null termination).
	NeededSizeString uint32 `idl:"name:neededSizeString" json:"needed_size_string"`
	// string: A pointer to a bytearray that, on return, contains a localized string containing
	// the message requested. This can contain a simple string, such as the localized name
	// of a keyword, or a fully rendered message that contains multiple inserts.
	String []byte `idl:"name:string;size_is:(, actualSizeString)" json:"string"`
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to loading the necessary resource.
	// All nonzero values MUST be treated the same. If the method succeeds, the server MUST
	// set all the fields in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcMessageRender return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

MessageRenderResponse structure represents the EvtRpcMessageRender operation response

func (*MessageRenderResponse) MarshalNDR 

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

func (*MessageRenderResponse) UnmarshalNDR 

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

type OpenLogRequest 

type OpenLogRequest struct {
	// channel: A pointer to a string that contains a channel or a file path.
	Channel string `idl:"name:channel;string" json:"channel"`
	// flags: MUST be one of the following two values.
	//
	//	+------------+---------------------------------------------+
	//	|            |                                             |
	//	|   VALUE    |                   MEANING                   |
	//	|            |                                             |
	//	+------------+---------------------------------------------+
	//	+------------+---------------------------------------------+
	//	| 0x00000001 | Channel parameter specifies a channel name. |
	//	+------------+---------------------------------------------+
	//	| 0x00000002 | Channel parameter specifies a file name.    |
	//	+------------+---------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

OpenLogRequest structure represents the EvtRpcOpenLogHandle operation request

func (*OpenLogRequest) MarshalNDR 

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

func (*OpenLogRequest) UnmarshalNDR 

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

type OpenLogResponse 

type OpenLogResponse struct {
	// handle: A pointer to a log handle. This parameter is an RPC context handle, as specified
	// in [C706], Context Handles.
	Handle *Log `idl:"name:handle" json:"handle"`
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The server MAY set the suberror fields to supply
	// more comprehensive error information.<35> If the method succeeds, the server MUST
	// set all of the values in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcOpenLogHandle return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

OpenLogResponse structure represents the EvtRpcOpenLogHandle operation response

func (*OpenLogResponse) MarshalNDR 

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

func (*OpenLogResponse) UnmarshalNDR 

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

type OperationControl 

type OperationControl dcetypes.ContextHandle

OperationControl structure represents PCONTEXT_HANDLE_OPERATION_CONTROL RPC structure.

func (*OperationControl) ContextHandle 

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

func (*OperationControl) MarshalNDR 

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

func (*OperationControl) UnmarshalNDR 

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

type PublisherMetadata 

type PublisherMetadata dcetypes.ContextHandle

PublisherMetadata structure represents PCONTEXT_HANDLE_PUBLISHER_METADATA RPC structure.

func (*PublisherMetadata) ContextHandle 

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

func (*PublisherMetadata) MarshalNDR 

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

func (*PublisherMetadata) UnmarshalNDR 

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

type PutChannelConfigRequest 

type PutChannelConfigRequest struct {
	// channelPath: A pointer to a string that contains a channel name (this is not a file
	// path as the parameter name might suggest).
	ChannelPath string `idl:"name:channelPath;string" json:"channel_path"`
	// flags: A 32-bit unsigned integer that indicates what to do depending on the existence
	// of the channel. This MUST be set to one of the following, and the server SHOULD return
	// ERROR_INVALID_PARAMETER (0x00000057) if the flag is not one of the following values.<40>
	//
	//	+------------+----------------------------------------------------------------------------------+
	//	|            |                                                                                  |
	//	|   VALUE    |                                     MEANING                                      |
	//	|            |                                                                                  |
	//	+------------+----------------------------------------------------------------------------------+
	//	+------------+----------------------------------------------------------------------------------+
	//	| 0x00000000 | The server MUST open the existing channel entry in its channel table or create a |
	//	|            | new entry if the specified channel is not in the table.                          |
	//	+------------+----------------------------------------------------------------------------------+
	//	| 0x00000001 | The server MUST open the existing channel entry in its channel table.            |
	//	+------------+----------------------------------------------------------------------------------+
	//	| 0x00000002 | Always create a new channel entry in the server's channel table and delete the   |
	//	|            | existing entry.                                                                  |
	//	+------------+----------------------------------------------------------------------------------+
	//	| 0x00000003 | Only create a new channel entry in the server's channel table.                   |
	//	+------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
	// props: A pointer to an EvtRpcVariantList (section 2.2.9) structure containing channel
	// properties, as defined in the following table.
	//
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|       |                          |                                                                                  |
	//	| INDEX |           TYPE           |                                     MEANING                                      |
	//	|       |                          |                                                                                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     0 | EvtRpcVarTypeBoolean     | Enabled. If true, the channel can accept new events. If false, any attempts to   |
	//	|       |                          | write events into this channel are automatically dropped.                        |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     1 | EvtRpcVarTypeUInt32      | Channel Isolation. It defines the default access permissions for the channel.    |
	//	|       |                          | Three values are allowed: 0: Application. 1: System. 2: Custom. The default      |
	//	|       |                          | isolation is Application. The default permissions for Application are (shown     |
	//	|       |                          | using SDDL): L"O:BAG:SYD:" L"(A;;0xf0007;;;SY)" // local system (read,           |
	//	|       |                          | write, clear) L"(A;;0x7;;;BA)" // built-in admins (read, write, clear)           |
	//	|       |                          | L"(A;;0x7;;;SO)" // server operators (read, write, clear) L"(A;;0x3;;;IU)"       |
	//	|       |                          | // INTERACTIVE LOGON (read, write) L"(A;;0x3;;;SU)" // SERVICES LOGON (read,     |
	//	|       |                          | write) L"(A;;0x3;;;S-1-5-3)" // BATCH LOGON (read, write) L"(A;;0x3;;;S-1-5-33)" |
	//	|       |                          | // write restricted service (read,write) L"(A;;0x1;;;S-1-5-32-573)"; //          |
	//	|       |                          | event log readers (read) The default permissions for System are (shown           |
	//	|       |                          | using SDDL): L"O:BAG:SYD:" L"(A;;0xf0007;;;SY)" // local system (read,           |
	//	|       |                          | write, clear) L"(A;;0x7;;;BA)" // built-in admins (read, write, clear)           |
	//	|       |                          | L"(A;;0x3;;;BO)" // backup operators (read, write) L"(A;;0x5;;;SO)" //           |
	//	|       |                          | server operators (read, clear) L"(A;;0x1;;;IU)" // INTERACTIVE LOGON (read)      |
	//	|       |                          | L"(A;;0x3;;;SU)" // SERVICES LOGON (read, write) L"(A;;0x1;;;S-1-5-3)" //        |
	//	|       |                          | BATCH LOGON (read) L"(A;;0x2;;;S-1-5-33)" // write restricted service (write)    |
	//	|       |                          | L"(A;;0x1;;;S-1-5-32-573)"; // event log readers (read) When the Custom value is |
	//	|       |                          | used, the Access property will contain the defined SDDL.                         |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     2 | EvtRpcVarTypeUInt32      | Channel Type. One of four values: 0: Admin 1: Operational. 2: Analytic 3: Debug  |
	//	|       |                          | For more information, see [MSDN-EVTLGCHWINEVTLG].                                |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     3 | EvtRpcVarTypeString      | OwningPublisher. The name of the publisher that defines and registers the        |
	//	|       |                          | channel with the system.                                                         |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     4 | EvtRpcVarTypeBoolean     | ClassicEventlog. If true, the channel represents an event log created according  |
	//	|       |                          | to the EventLog Remoting Protocol, not this protocol (EventLog Remoting Protocol |
	//	|       |                          | Version 6.0).                                                                    |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     5 | EvtRpcVarTypeString      | Access. A Security Descriptor Description Language (SDDL) string, as specified   |
	//	|       |                          | in [MS-DTYP], that represents access permissions to the channels. If the         |
	//	|       |                          | isolation attribute is set to Application or System, the access descriptor       |
	//	|       |                          | controls read access to the file (the write permissions are ignored). If the     |
	//	|       |                          | isolation attribute is set to Custom, the access descriptor controls write       |
	//	|       |                          | access to the channel and read access to the file.                               |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     6 | EvtRpcVarTypeBoolean     | Retention. If set to true, events can never be overwritten unless explicitly     |
	//	|       |                          | cleared. This is the way to configure the logs to be circular. If set to false,  |
	//	|       |                          | events are overwritten as needed when the event log is full.                     |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     7 | EvtRpcVarTypeBoolean     | AutoBackup. When set to true, the event log file associated with the channel is  |
	//	|       |                          | closed as soon as it reaches the maximum size specified by the MaxSize property, |
	//	|       |                          | and a new file is opened to accept new events. If the new file reaches maximum   |
	//	|       |                          | size, another new file will be generated and the previous new file will be       |
	//	|       |                          | backed up. The events in backed up files cannot be queried from this channel in  |
	//	|       |                          | the server unless the client specifies the backup log file names in a separate   |
	//	|       |                          | query.                                                                           |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     8 | EvtRpcVarTypeUInt64      | MaxSize. The value that indicates at which point the size (in bytes) of the      |
	//	|       |                          | event log file stops increasing. When the size is greater than or equal to this  |
	//	|       |                          | value, the file growth stops.                                                    |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|     9 | EvtRpcVarTypeString      | LogFilePath. The server changes the file path to the event log file for the      |
	//	|       |                          | channel.                                                                         |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    10 | EvtRpcVarTypeUInt32      | Level. Events with a level property less than or equal to this specified value   |
	//	|       |                          | are logged to the channel.                                                       |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    11 | EvtRpcVarTypeUInt64      | Keywords. Events with a keyword bit contained in the keywords bitmask set are    |
	//	|       |                          | logged to the channel.                                                           |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    12 | EvtRpcVarTypeGuid        | ControlGuid. A GUID value. The server SHOULD ignore this value.<41>              |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    19 | EvtRpcVarTypeStringArray | PublisherList. A list of publishers that can raise events into the channel.      |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	//	|    20 | EvtRpcVarTypeUInt32      | FileMax. The maximum number of log files associated with an analytic or debug    |
	//	|       |                          | channel. When the number of logs reaches the specified maximum, the system       |
	//	|       |                          | begins to overwrite the logs, beginning with the oldest. A FileMax value of 0 or |
	//	|       |                          | 1 indicates that only one file is associated with this channel. A MaxFile of 0   |
	//	|       |                          | is the default.                                                                  |
	//	+-------+--------------------------+----------------------------------------------------------------------------------+
	Properties *VariantList `idl:"name:props" json:"properties"`
}

PutChannelConfigRequest structure represents the EvtRpcPutChannelConfig operation request

func (*PutChannelConfigRequest) MarshalNDR 

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

func (*PutChannelConfigRequest) UnmarshalNDR 

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

type PutChannelConfigResponse 

type PutChannelConfigResponse struct {
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to a particular property. All
	// nonzero values MUST be treated the same. If the method succeeds, the server MUST
	// set all of the values in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcPutChannelConfig return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

PutChannelConfigResponse structure represents the EvtRpcPutChannelConfig operation response

func (*PutChannelConfigResponse) MarshalNDR 

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

func (*PutChannelConfigResponse) UnmarshalNDR 

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

type QueryChannelInfo 

type QueryChannelInfo struct {
	// name:  Name of the channel to which the status applies.
	Name string `idl:"name:name" json:"name"`
	// status:   A Win32 error code that indicates the channel status. A value of 0x00000000
	// indicates success; any other value indicates failure. Unless otherwise noted, all
	// failure values MUST be treated equally.
	Status uint32 `idl:"name:status" json:"status"`
}

QueryChannelInfo structure represents EvtRpcQueryChannelInfo RPC structure.

The format of the EvtRpcQueryChannelInfo data type is as follows.

func (*QueryChannelInfo) MarshalNDR 

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

func (*QueryChannelInfo) UnmarshalNDR 

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

type QueryNextRequest 

type QueryNextRequest struct {
	// logQuery: A handle to an event log. This parameter is an RPC context handle, as specified
	// in [C706], Context Handles.
	LogQuery *LogQuery `idl:"name:logQuery" json:"log_query"`
	// numRequestedRecords: A 32-bit unsigned integer that contains the number of events
	// to return.<19>
	RequestedRecordsLength uint32 `idl:"name:numRequestedRecords" json:"requested_records_length"`
	// timeOutEnd: A 32-bit unsigned integer that contains the maximum number of milliseconds
	// to wait before returning, starting from the time the server begins processing the
	// call.
	TimeoutEnd uint32 `idl:"name:timeOutEnd" json:"timeout_end"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<20>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

QueryNextRequest structure represents the EvtRpcQueryNext operation request

func (*QueryNextRequest) MarshalNDR 

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

func (*QueryNextRequest) UnmarshalNDR 

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

type QueryNextResponse 

type QueryNextResponse struct {
	// numActualRecords: A pointer to a 32-bit unsigned integer that contains the value
	// that, on success, MUST be set to the number of events that are retrieved. This is
	// useful when the method times out without receiving the full number of events specified
	// in numRequestedRecords. If the method fails, the client MUST NOT use the value.
	ActualRecordsLength uint32 `idl:"name:numActualRecords" json:"actual_records_length"`
	// eventDataIndices: A pointer to an array of 32-bit unsigned integers that contain
	// the offsets (in bytes) within the resultBuffer for the events that are read.
	EventDataIndices []uint32 `idl:"name:eventDataIndices;size_is:(, numActualRecords)" json:"event_data_indices"`
	// eventDataSizes: A pointer to an array of 32-bit unsigned integers that contain the
	// sizes (in bytes) within the resultBuffer for the events that are read.
	EventDataSizes []uint32 `idl:"name:eventDataSizes;size_is:(, numActualRecords)" json:"event_data_sizes"`
	// resultBufferSize: A pointer to a 32-bit unsigned integer that contains the number
	// of bytes of data returned in resultBuffer.
	ResultBufferSize uint32 `idl:"name:resultBufferSize" json:"result_buffer_size"`
	// resultBuffer: A pointer to a byte-array that contains the result set of one or more
	// events. The events MUST be in binary XML format, as specified in section 2.2.17.
	ResultBuffer []byte `idl:"name:resultBuffer;size_is:(, resultBufferSize)" json:"result_buffer"`
	// Return: The EvtRpcQueryNext return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

QueryNextResponse structure represents the EvtRpcQueryNext operation response

func (*QueryNextResponse) MarshalNDR 

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

func (*QueryNextResponse) UnmarshalNDR 

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

type QuerySeekRequest 

type QuerySeekRequest struct {
	// logQuery: A handle to an event log. This parameter is an RPC context handle, as specified
	// in [C706], Context Handles.
	LogQuery *LogQuery `idl:"name:logQuery" json:"log_query"`
	// pos: The number of records in the result set to move by. If the number is positive,
	// the movement is the same as the direction of the query that was specified in the
	// EvtRpcRegisterLogQuery (section 3.1.4.12) method call that was used to obtain the
	// handle specified by the logQuery parameter. If the number is negative, the movement
	// is in the opposite direction of the query.
	Pos int64 `idl:"name:pos" json:"pos"`
	// bookmarkXml: A pointer to a string that contains a bookmark.
	BookmarkXML string `idl:"name:bookmarkXml;string;pointer:unique" json:"bookmark_xml"`
	// timeOut: A 32-bit unsigned integer that MUST be set to 0x00000000 when sent and MAY
	// be ignored on receipt.
	Timeout uint32 `idl:"name:timeOut" json:"timeout"`
	// flags: This MUST be set as follows: this 32-bit unsigned integer contains flags that
	// describe the absolute position from which EvtRpcQuerySeek (Opnum 12) starts its seek.
	// The origin flags (the first four flags that follow) are mutually exclusive; however,
	// the last flag can be set independently. The pos parameter specifies the offset used
	// in the definitions of these flags.
	//
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	|                                      |                                                                                  |
	//	|                VALUE                 |                                     MEANING                                      |
	//	|                                      |                                                                                  |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSeekRelativeToFirst 0x00000001    | The offset is relative to the first entry in the result set and SHOULD be        |
	//	|                                      | nonnegative. Therefore, if an offset of 0 is specified, the cursor is moved to   |
	//	|                                      | the first entry in the result set.                                               |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSeekRelativeToLast 0x00000002     | The offset is relative to the last entry in the result set and SHOULD be         |
	//	|                                      | nonpositive. Therefore, if an offset of 0 is specified, the cursor is moved to   |
	//	|                                      | the last entry in the result set.                                                |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSeekRelativeToCurrent 0x00000003  | The offset is relative to the current cursor location. If an offset of 0 is      |
	//	|                                      | specified, the cursor is not to be moved. A positive or negative number can be   |
	//	|                                      | used in this case to move the cursor to any other location.                      |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSeekRelativeToBookmark 0x00000004 | The offset is relative to the bookmark location. If an offset of 0 is specified, |
	//	|                                      | the cursor is positioned at the bookmark. A positive or negative number can be   |
	//	|                                      | used in this case to move the cursor to any other location. The server MUST fail |
	//	|                                      | the operation if the bookmarkXml parameter does not specify a valid position in  |
	//	|                                      | the log. The presence of the EvtSeekStrict flag SHOULD influence the behavior of |
	//	|                                      | this flag, as specified below.                                                   |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSeekStrict 0x00010000             | If this is set, the query fails if the seek cannot go to the record indicated    |
	//	|                                      | by the other flags/parameters. If not set, the seek uses a best effort. For      |
	//	|                                      | example, if 99 records remain in the result set and the pos parameter specifies  |
	//	|                                      | 100 with the EvtSeekRelativeToCurrent flag set, the 99th record is selected.     |
	//	+--------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

QuerySeekRequest structure represents the EvtRpcQuerySeek operation request

func (*QuerySeekRequest) MarshalNDR 

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

func (*QuerySeekRequest) UnmarshalNDR 

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

type QuerySeekResponse 

type QuerySeekResponse struct {
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo structure fields MUST be set to
	// nonzero values if the error is related to parsing the query. In addition, the server
	// MAY set the structure fields to nonzero values for errors unrelated to query parsing.
	// All nonzero values MUST be treated the same by the client.
	//
	// If the method succeeds, the server MUST set all the values in the structure to zero.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcQuerySeek return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

QuerySeekResponse structure represents the EvtRpcQuerySeek operation response

func (*QuerySeekResponse) MarshalNDR 

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

func (*QuerySeekResponse) UnmarshalNDR 

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

type RegisterControllableOperationRequest 

type RegisterControllableOperationRequest struct {
}

RegisterControllableOperationRequest structure represents the EvtRpcRegisterControllableOperation operation request

func (*RegisterControllableOperationRequest) MarshalNDR 

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

func (*RegisterControllableOperationRequest) UnmarshalNDR 

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

type RegisterControllableOperationResponse 

type RegisterControllableOperationResponse struct {
	// handle: A context handle for a control object. This parameter MUST be an RPC context
	// handle, as specified in [C706], Context Handles. For information on handle security
	// and authentication considerations, see sections 2.2.20 and 5.1.
	Handle *OperationControl `idl:"name:handle" json:"handle"`
	// Return: The EvtRpcRegisterControllableOperation return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

RegisterControllableOperationResponse structure represents the EvtRpcRegisterControllableOperation operation response

func (*RegisterControllableOperationResponse) MarshalNDR 

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

func (*RegisterControllableOperationResponse) UnmarshalNDR 

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

type RegisterLogQueryRequest 

type RegisterLogQueryRequest struct {
	// path: A pointer to a string that contains a channel or file path.
	Path string `idl:"name:path;string;pointer:unique" json:"path"`
	// query: A pointer to a string that contains a query that specifies events of interest
	// to the application. The pointer MUST be either an XPath filter, as specified in section
	// 2.2.15, or a query, as specified in section 2.2.16.
	Query string `idl:"name:query;string" json:"query"`
	// flags: The flags field MUST be set as follows. The first two bits indicate how the
	// path argument MUST be interpreted. Callers MUST specify one and only one value.
	//
	//	+--------------------------------+--------------------------------+
	//	|                                |                                |
	//	|             VALUE              |            MEANING             |
	//	|                                |                                |
	//	+--------------------------------+--------------------------------+
	//	+--------------------------------+--------------------------------+
	//	| EvtQueryChannelPath 0x00000001 | Path specifies a channel name. |
	//	+--------------------------------+--------------------------------+
	//	| EvtQueryFilePath 0x00000002    | Path specifies a file name.    |
	//	+--------------------------------+--------------------------------+
	//
	// These bits control the direction of the query. Callers MUST specify one and only
	// one value.
	//
	//	+------------+----------------------------------------+
	//	|            |                                        |
	//	|   VALUE    |                MEANING                 |
	//	|            |                                        |
	//	+------------+----------------------------------------+
	//	+------------+----------------------------------------+
	//	| 0x00000100 | Events are read from oldest to newest. |
	//	+------------+----------------------------------------+
	//	| 0x00000200 | Events are read from newest to oldest. |
	//	+------------+----------------------------------------+
	//
	// The following bit can be set independently of the previously mentioned bits.
	//
	//	+------------+----------------------------------------------------------------------------------+
	//	|            |                                                                                  |
	//	|   VALUE    |                                     MEANING                                      |
	//	|            |                                                                                  |
	//	+------------+----------------------------------------------------------------------------------+
	//	+------------+----------------------------------------------------------------------------------+
	//	| 0x00001000 | Specifies to return the query result set even if one or more errors result from  |
	//	|            | the query. For example, if a structured XML query specifies multiple channels,   |
	//	|            | some channels are valid while others are not. A query that is used on many       |
	//	|            | computers might be sent to a computer that is missing one or more channels in    |
	//	|            | the query. If this bit is not set, the server MUST fail the query. If this bit   |
	//	|            | is set, the query MUST succeed even if all channels are not present.             |
	//	+------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

RegisterLogQueryRequest structure represents the EvtRpcRegisterLogQuery operation request

func (*RegisterLogQueryRequest) MarshalNDR 

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

func (*RegisterLogQueryRequest) UnmarshalNDR 

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

type RegisterLogQueryResponse 

type RegisterLogQueryResponse struct {
	// handle: A pointer to a query handle. This parameter MUST be an RPC context handle,
	// as specified in [C706], Context Handles.
	Handle *LogQuery `idl:"name:handle" json:"handle"`
	// opControl: A pointer to a control handle. This parameter MUST be an RPC context handle,
	// as specified in [C706], Context Handles.
	OperationControl *OperationControl `idl:"name:opControl" json:"operation_control"`
	// queryChannelInfoSize: A pointer to a 32-bit unsigned integer that contains the number
	// of EvtRpcQueryChannelInfo structures returned in queryChannelInfo.
	QueryChannelInfoSize uint32 `idl:"name:queryChannelInfoSize" json:"query_channel_info_size"`
	// queryChannelInfo: A pointer to an array of section EvtRpcQueryChannelInfo structures,
	// as specified in section 2.2.11.
	QueryChannelInfo []*QueryChannelInfo `idl:"name:queryChannelInfo;size_is:(, queryChannelInfoSize)" json:"query_channel_info"`
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to parsing the query; in addition,
	// the server MAY set the structure fields to nonzero values for errors unrelated to
	// query parsing (for example, for an invalid channel name). All nonzero values MUST
	// be treated the same. If the method succeeds, the server MUST set all the fields in
	// the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcRegisterLogQuery return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

RegisterLogQueryResponse structure represents the EvtRpcRegisterLogQuery operation response

func (*RegisterLogQueryResponse) MarshalNDR 

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

func (*RegisterLogQueryResponse) UnmarshalNDR 

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

type RegisterRemoteSubscriptionRequest 

type RegisterRemoteSubscriptionRequest struct {
	// channelPath: A pointer to a string that contains a channel name or is a null pointer.
	// In the case of a null pointer, the query field indicates the channels to which the
	// subscription applies.
	ChannelPath string `idl:"name:channelPath;string;pointer:unique" json:"channel_path"`
	// query: A pointer to a string that contains a query that specifies events of interest
	// to the application. The pointer MUST be either an XPath filter, as specified in section
	// 2.2.15, or a query as specified in section 2.2.16.
	Query string `idl:"name:query;string" json:"query"`
	// bookmarkXml: Either NULL or a pointer to a string that contains a bookmark indicating
	// the last event that the client processed during a previous subscription. The server
	// MUST ignore the bookmarkXML parameter unless the flags field has the bit 0x00000003
	// set.
	BookmarkXML string `idl:"name:bookmarkXml;string;pointer:unique" json:"bookmark_xml"`
	// flags: Flags that determine the behavior of the query.
	//
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//	|                                            |                                                                    |
	//	|                   VALUE                    |                              MEANING                               |
	//	|                                            |                                                                    |
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//	| EvtSubscribeToFutureEvents 0x00000001      | Get events starting from the present time.                         |
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//	| EvtSubscribeStartAtOldestRecord 0x00000002 | Get all events from the logs, and any future events.               |
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//	| EvtSubscribeStartAfterBookmark 0x00000003  | Get all events starting after the event indicated by the bookmark. |
	//	+--------------------------------------------+--------------------------------------------------------------------+
	//
	// The following bits control other aspects of the subscription. These bits are set
	// independently of the flags defined for the lower two bits, and independently of each
	// other.
	//
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                            |                                                                                  |
	//	|                   VALUE                    |                                     MEANING                                      |
	//	|                                            |                                                                                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSubscribeTolerateQueryErrors 0x00001000 | The server does not fail the function as long as there is one valid channel.     |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSubscribeStrict 0x00010000              | Fail if any events are missed for reasons such as log clearing.                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| EvtSubscribePull 0x10000000                | Subscription is going to be a pull subscription. A pull subscription requires    |
	//	|                                            | the client to call the EvtRpcRemoteSubscriptionNext (as specified in section     |
	//	|                                            | 3.1.4.10) method to fetch the subscribed events. If this flag is not set, the    |
	//	|                                            | subscription is a push subscription. A push subscription requires the client to  |
	//	|                                            | call the EvtRpcRemoteSubscriptionNextAsync (as specified in section 3.1.4.9) to  |
	//	|                                            | receive notifications from the server when the subscribed events arrive.         |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

RegisterRemoteSubscriptionRequest structure represents the EvtRpcRegisterRemoteSubscription operation request

func (*RegisterRemoteSubscriptionRequest) MarshalNDR 

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

func (*RegisterRemoteSubscriptionRequest) UnmarshalNDR 

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

type RegisterRemoteSubscriptionResponse 

type RegisterRemoteSubscriptionResponse struct {
	// handle: A context handle for the subscription. This parameter is an RPC context handle,
	// as specified in [C706], Context Handles.
	Handle *RemoteSubscription `idl:"name:handle" json:"handle"`
	// control: A context handle for the subscription. This parameter is an RPC context
	// handle, as specified in [C706], Context Handles.
	Control *OperationControl `idl:"name:control" json:"control"`
	// queryChannelInfoSize: A pointer to a 32-bit unsigned integer that contains the number
	// of EvtRpcQueryChannelInfo structures returned in queryChannelInfo.
	QueryChannelInfoSize uint32 `idl:"name:queryChannelInfoSize" json:"query_channel_info_size"`
	// queryChannelInfo: A pointer to an array of EvtRpcQueryChannelInfo (section 2.2.11)
	// structures that indicate the status of each channel in the subscription.
	QueryChannelInfo []*QueryChannelInfo `idl:"name:queryChannelInfo;size_is:(, queryChannelInfoSize)" json:"query_channel_info"`
	// error: A pointer to an RpcInfo (section 2.2.1) structure in which to place error
	// information in the case of a failure. The RpcInfo (section 2.2.1) structure fields
	// MUST be set to nonzero values if the error is related to parsing the query. If the
	// method succeeds, the server MUST set all of the values in the structure to 0.
	Error *Info `idl:"name:error" json:"error"`
	// Return: The EvtRpcRegisterRemoteSubscription return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

RegisterRemoteSubscriptionResponse structure represents the EvtRpcRegisterRemoteSubscription operation response

func (*RegisterRemoteSubscriptionResponse) MarshalNDR 

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

func (*RegisterRemoteSubscriptionResponse) UnmarshalNDR 

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

type RemoteSubscription 

type RemoteSubscription dcetypes.ContextHandle

RemoteSubscription structure represents PCONTEXT_HANDLE_REMOTE_SUBSCRIPTION RPC structure.

func (*RemoteSubscription) ContextHandle 

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

func (*RemoteSubscription) MarshalNDR 

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

func (*RemoteSubscription) UnmarshalNDR 

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

type RemoteSubscriptionNextAsyncRequest 

type RemoteSubscriptionNextAsyncRequest struct {
	// handle: A handle to the subscription. This parameter is an RPC context handle, as
	// specified in [C706], Context Handles.
	Handle *RemoteSubscription `idl:"name:handle" json:"handle"`
	// numRequestedRecords: A 32-bit unsigned integer that contains the number of events
	// to return.
	RequestedRecordsLength uint32 `idl:"name:numRequestedRecords" json:"requested_records_length"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<13>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

RemoteSubscriptionNextAsyncRequest structure represents the EvtRpcRemoteSubscriptionNextAsync operation request

func (*RemoteSubscriptionNextAsyncRequest) MarshalNDR 

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

func (*RemoteSubscriptionNextAsyncRequest) UnmarshalNDR 

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

type RemoteSubscriptionNextAsyncResponse 

type RemoteSubscriptionNextAsyncResponse struct {
	// numActualRecords: A pointer to a 32-bit unsigned integer that contains the value
	// that, on success, MUST be set to the number of events retrieved. This might be used,
	// for example, if the method times out without receiving the full number of events
	// specified in numRequestedRecords.
	ActualRecordsLength uint32 `idl:"name:numActualRecords" json:"actual_records_length"`
	// eventDataIndices: A pointer to an array of 32-bit unsigned integers that contain
	// the offsets for the event. An event's offset is its position relative to the start
	// of resultBuffer.
	EventDataIndices []uint32 `idl:"name:eventDataIndices;size_is:(, numActualRecords)" json:"event_data_indices"`
	// eventDataSizes: A pointer to an array of 32-bit unsigned integers that contain the
	// event sizes in bytes.
	EventDataSizes []uint32 `idl:"name:eventDataSizes;size_is:(, numActualRecords)" json:"event_data_sizes"`
	// resultBufferSize: A pointer to a 32-bit unsigned integer that contains the number
	// of bytes of data returned in resultBuffer.
	ResultBufferSize uint32 `idl:"name:resultBufferSize" json:"result_buffer_size"`
	// resultBuffer: A pointer to a byte-array that contains the result set of one or more
	// events. The events MUST be in binary XML format, as specified in section 2.2.17.
	ResultBuffer []byte `idl:"name:resultBuffer;size_is:(, resultBufferSize)" json:"result_buffer"`
	// Return: The EvtRpcRemoteSubscriptionNextAsync return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

RemoteSubscriptionNextAsyncResponse structure represents the EvtRpcRemoteSubscriptionNextAsync operation response

func (*RemoteSubscriptionNextAsyncResponse) MarshalNDR 

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

func (*RemoteSubscriptionNextAsyncResponse) UnmarshalNDR 

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

type RemoteSubscriptionNextRequest 

type RemoteSubscriptionNextRequest struct {
	// handle: A handle to a subscription. This parameter is an RPC context handle, as specified
	// in [C706] Context Handles.
	Handle *RemoteSubscription `idl:"name:handle" json:"handle"`
	// numRequestedRecords: A 32-bit unsigned integer that contains the maximum number of
	// events to return.
	RequestedRecordsLength uint32 `idl:"name:numRequestedRecords" json:"requested_records_length"`
	// timeOut: A 32-bit unsigned integer that contains the maximum number of milliseconds
	// to wait before returning.
	Timeout uint32 `idl:"name:timeOut" json:"timeout"`
	// flags: A 32-bit unsigned integer that MUST be set to zero when sent and MAY be ignored
	// on receipt.<15>
	Flags uint32 `idl:"name:flags" json:"flags"`
}

RemoteSubscriptionNextRequest structure represents the EvtRpcRemoteSubscriptionNext operation request

func (*RemoteSubscriptionNextRequest) MarshalNDR 

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

func (*RemoteSubscriptionNextRequest) UnmarshalNDR 

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

type RemoteSubscriptionNextResponse 

type RemoteSubscriptionNextResponse struct {
	// numActualRecords: A pointer to a 32-bit unsigned integer that contains the value
	// that, on success, MUST be set to the number of events that are retrieved. This is
	// useful in the case in which the method times out without receiving the full number
	// of events specified in numRequestedRecords. If the method fails, the client MUST
	// NOT use the value.
	ActualRecordsLength uint32 `idl:"name:numActualRecords" json:"actual_records_length"`
	// eventDataIndices: A pointer to an array of 32-bit unsigned integers that contain
	// the offsets for the events. An event offset is its position relative to the start
	// of resultBuffer.
	EventDataIndices []uint32 `idl:"name:eventDataIndices;size_is:(, numActualRecords)" json:"event_data_indices"`
	// eventDataSizes: A pointer to an array of 32-bit unsigned integers that contain the
	// event sizes in bytes.
	EventDataSizes []uint32 `idl:"name:eventDataSizes;size_is:(, numActualRecords)" json:"event_data_sizes"`
	// resultBufferSize: A pointer to a 32-bit unsigned integer that contains the number
	// of bytes of data returned in resultBuffer.
	ResultBufferSize uint32 `idl:"name:resultBufferSize" json:"result_buffer_size"`
	// resultBuffer: A pointer to a byte-array that contains the result set of one or more
	// events. The events MUST be in binary XML format, as specified in section 2.2.17.
	ResultBuffer []byte `idl:"name:resultBuffer;size_is:(, resultBufferSize)" json:"result_buffer"`
	// Return: The EvtRpcRemoteSubscriptionNext return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

RemoteSubscriptionNextResponse structure represents the EvtRpcRemoteSubscriptionNext operation response

func (*RemoteSubscriptionNextResponse) MarshalNDR 

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

func (*RemoteSubscriptionNextResponse) UnmarshalNDR 

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

type RemoteSubscriptionWaitAsyncRequest 

type RemoteSubscriptionWaitAsyncRequest struct {
	// handle: A handle to a subscription, as obtained from the EvtRpcRegisterRemoteSubscription
	// (section 3.1.4.8) method. This parameter MUST be an RPC context handle, as specified
	// in [C706] Context Handles.
	Handle *RemoteSubscription `idl:"name:handle" json:"handle"`
}

RemoteSubscriptionWaitAsyncRequest structure represents the EvtRpcRemoteSubscriptionWaitAsync operation request

func (*RemoteSubscriptionWaitAsyncRequest) MarshalNDR 

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

func (*RemoteSubscriptionWaitAsyncRequest) UnmarshalNDR 

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

type RemoteSubscriptionWaitAsyncResponse 

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

RemoteSubscriptionWaitAsyncResponse structure represents the EvtRpcRemoteSubscriptionWaitAsync operation response

func (*RemoteSubscriptionWaitAsyncResponse) MarshalNDR 

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

func (*RemoteSubscriptionWaitAsyncResponse) UnmarshalNDR 

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

type RetractConfigRequest 

type RetractConfigRequest struct {
	// path: A pointer to a string that contains a channel or publisher name to be removed.
	Path string `idl:"name:path;string" json:"path"`
	// flags: A 32-bit unsigned integer that indicates how the path parameter is to be interpreted.
	// This MUST be set as follows.
	//
	//	+--------------------------------+----------------------------------+
	//	|                                |                                  |
	//	|             VALUE              |             MEANING              |
	//	|                                |                                  |
	//	+--------------------------------+----------------------------------+
	//	+--------------------------------+----------------------------------+
	//	| EvtRpcChannelPath 0x00000000   | Path specifies a channel name.   |
	//	+--------------------------------+----------------------------------+
	//	| EvtRpcPublisherName 0x00000001 | Path specifies a publisher name. |
	//	+--------------------------------+----------------------------------+
	Flags uint32 `idl:"name:flags" json:"flags"`
}

RetractConfigRequest structure represents the EvtRpcRetractConfig operation request

func (*RetractConfigRequest) MarshalNDR 

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

func (*RetractConfigRequest) UnmarshalNDR 

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

type RetractConfigResponse 

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

RetractConfigResponse structure represents the EvtRpcRetractConfig operation response

func (*RetractConfigResponse) MarshalNDR 

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

func (*RetractConfigResponse) UnmarshalNDR 

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

type StringArray 

type StringArray struct {
	// count:  A 32-bit unsigned integer that contains the number of strings pointed to
	// by ptr.
	Count uint32 `idl:"name:count" json:"count"`
	// ptr:  A pointer to an array of null-terminated Unicode (as specified in [UNICODE])
	// strings.
	Array []string `idl:"name:ptr;size_is:(count);string" json:"array"`
}

StringArray structure represents StringArray RPC structure.

The StringArray structure is defined as follows.

func (*StringArray) MarshalNDR 

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

func (*StringArray) UnmarshalNDR 

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

type Uint32Array 

type Uint32Array struct {
	// count:  An unsigned 32-bit integer that contains the number of unsigned 32-bit integers
	// pointed to by ptr.
	Count uint32 `idl:"name:count" json:"count"`
	// ptr:  A pointer to an array of unsigned 32-bit integers.
	Array []uint32 `idl:"name:ptr;size_is:(count)" json:"array"`
}

Uint32Array structure represents UInt32Array RPC structure.

The UInt32Array structure is defined as follows.

func (*Uint32Array) MarshalNDR 

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

func (*Uint32Array) UnmarshalNDR 

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

type Uint64Array 

type Uint64Array struct {
	// count:  A 32-bit unsigned integer that contains the number of 64-bit integers pointed
	// to by ptr.
	Count uint32 `idl:"name:count" json:"count"`
	// ptr:  A pointer to an array of unsigned 64-bit integers.
	Array []uint64 `idl:"name:ptr;size_is:(count)" json:"array"`
}

Uint64Array structure represents UInt64Array RPC structure.

The UInt64Array structure is defined as follows.

func (*Uint64Array) MarshalNDR 

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

func (*Uint64Array) UnmarshalNDR 

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

type Variant 

type Variant struct {
	// type:  Indicates the actual type of the union.
	Type VariantType `idl:"name:type" json:"type"`
	// flags:   This flag MUST be set to either 0x0000 or 0x0001. If this flag is set to
	// 0x0001, it indicates that an EvtRpcVariant structure has been changed by the client.
	// For an example of how this flag might be set, suppose the client application retrieved
	// an EvtRpcVariantList structure by calling EvtRpcGetChannelConfig, changed one or
	// more EvtRpcVariant structures in the list, and then sent the list back to the server
	// via EvtRpcPutChannelConfig. In this example, the server updates the values corresponding
	// to the EvtRpcVariant structures with this flag set.
	//
	//	+--------+----------------------------------------------------------------------------------+
	//	|        |                                                                                  |
	//	| VALUE  |                                     MEANING                                      |
	//	|        |                                                                                  |
	//	+--------+----------------------------------------------------------------------------------+
	//	+--------+----------------------------------------------------------------------------------+
	//	| 0x0000 | A flag indicating that no instance of an EvtRpcVariant structure was changed by  |
	//	|        | the client.                                                                      |
	//	+--------+----------------------------------------------------------------------------------+
	//	| 0x0001 | A flag indicating that an EvtRpcVariant structure was changed by the client.     |
	//	+--------+----------------------------------------------------------------------------------+
	Flags   uint32           `idl:"name:flags" json:"flags"`
	Variant *Variant_Variant `idl:"name:Variant;switch_is:type" json:"variant"`
}

Variant structure represents EvtRpcVariant RPC structure.

The EvtRpcVariant structure is defined as follows.

func (*Variant) MarshalNDR 

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

func (*Variant) UnmarshalNDR 

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

type VariantList 

type VariantList struct {
	// count:  Number of EvtRpcVariant values pointed to by the props field.
	Count uint32 `idl:"name:count" json:"count"`
	// props:  Pointer to an array of EvtRpcVariant values.
	Properties []*Variant `idl:"name:props;size_is:(count)" json:"properties"`
}

VariantList structure represents EvtRpcVariantList RPC structure.

The EvtRpcVariantList data type is a wrapper for multiple EvtRpcVariant (section 2.2.7) data types.

func (*VariantList) MarshalNDR 

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

func (*VariantList) UnmarshalNDR 

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

type VariantType 

type VariantType uint32

VariantType type represents EvtRpcVariantType RPC enumeration. 

var (
	VariantTypeNull         VariantType = 0
	VariantTypeBoolean      VariantType = 1
	VariantTypeUint32       VariantType = 2
	VariantTypeUint64       VariantType = 3
	VariantTypeString       VariantType = 4
	VariantTypeGUID         VariantType = 5
	VariantTypeBooleanArray VariantType = 6
	VariantTypeUint32Array  VariantType = 7
	VariantTypeUint64Array  VariantType = 8
	VariantTypeStringArray  VariantType = 9
	VariantTypeGUIDArray    VariantType = 10
)

func (VariantType) String 

func (o VariantType) String() string

type Variant_BooleanArray 

type Variant_BooleanArray struct {
	// booleanArray:  An array of BOOLEAN values that are stored as a BooleanArray.
	BooleanArray *BooleanArray `idl:"name:booleanArray" json:"boolean_array"`
}

Variant_BooleanArray structure represents Variant_Variant RPC union arm.

It has following labels: 6

func (*Variant_BooleanArray) MarshalNDR 

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

func (*Variant_BooleanArray) UnmarshalNDR 

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

type Variant_BooleanValue 

type Variant_BooleanValue struct {
	// booleanVal:  A BOOLEAN value.
	BooleanValue bool `idl:"name:booleanVal" json:"boolean_value"`
}

Variant_BooleanValue structure represents Variant_Variant RPC union arm.

It has following labels: 1

func (*Variant_BooleanValue) MarshalNDR 

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

func (*Variant_BooleanValue) UnmarshalNDR 

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

type Variant_GUIDArray 

type Variant_GUIDArray struct {
	// guidArray:  An array of GUIDs that are stored as a GuidArray.
	GUIDArray *GUIDArray `idl:"name:guidArray" json:"guid_array"`
}

Variant_GUIDArray structure represents Variant_Variant RPC union arm.

It has following labels: 10

func (*Variant_GUIDArray) MarshalNDR 

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

func (*Variant_GUIDArray) UnmarshalNDR 

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

type Variant_GUIDValue 

type Variant_GUIDValue struct {
	// guidVal:  A GUID.
	GUIDValue *dtyp.GUID `idl:"name:guidVal" json:"guid_value"`
}

Variant_GUIDValue structure represents Variant_Variant RPC union arm.

It has following labels: 5

func (*Variant_GUIDValue) MarshalNDR 

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

func (*Variant_GUIDValue) UnmarshalNDR 

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

type Variant_NullValue 

type Variant_NullValue struct {
	// nullVal:  MUST be set to 0x00000000.
	NullValue int32 `idl:"name:nullVal" json:"null_value"`
}

Variant_NullValue structure represents Variant_Variant RPC union arm.

It has following labels: 0

func (*Variant_NullValue) MarshalNDR 

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

func (*Variant_NullValue) UnmarshalNDR 

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

type Variant_StringArray 

type Variant_StringArray struct {
	// stringArray:  An array of strings that are stored as a StringArray.
	StringArray *StringArray `idl:"name:stringArray" json:"string_array"`
}

Variant_StringArray structure represents Variant_Variant RPC union arm.

It has following labels: 9

func (*Variant_StringArray) MarshalNDR 

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

func (*Variant_StringArray) UnmarshalNDR 

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

type Variant_StringValue 

type Variant_StringValue struct {
	// stringVal:  A null-terminated UNICODE string.
	StringValue string `idl:"name:stringVal;string" json:"string_value"`
}

Variant_StringValue structure represents Variant_Variant RPC union arm.

It has following labels: 4

func (*Variant_StringValue) MarshalNDR 

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

func (*Variant_StringValue) UnmarshalNDR 

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

type Variant_Uint32Array 

type Variant_Uint32Array struct {
	// uint32Array:  An array of 32-bit unsigned integers that are stored as a UInt32Array.
	Uint32Array *Uint32Array `idl:"name:uint32Array" json:"uint32_array"`
}

Variant_Uint32Array structure represents Variant_Variant RPC union arm.

It has following labels: 7

func (*Variant_Uint32Array) MarshalNDR 

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

func (*Variant_Uint32Array) UnmarshalNDR 

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

type Variant_Uint32Value 

type Variant_Uint32Value struct {
	// uint32Val:  A 32-bit unsigned integer.
	Uint32Value uint32 `idl:"name:uint32Val" json:"uint32_value"`
}

Variant_Uint32Value structure represents Variant_Variant RPC union arm.

It has following labels: 2

func (*Variant_Uint32Value) MarshalNDR 

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

func (*Variant_Uint32Value) UnmarshalNDR 

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

type Variant_Uint64Array 

type Variant_Uint64Array struct {
	// uint64Array:  An array of 64-bit unsigned integers that are stored as a UInt64Array.
	Uint64Array *Uint64Array `idl:"name:uint64Array" json:"uint64_array"`
}

Variant_Uint64Array structure represents Variant_Variant RPC union arm.

It has following labels: 8

func (*Variant_Uint64Array) MarshalNDR 

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

func (*Variant_Uint64Array) UnmarshalNDR 

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

type Variant_Uint64Value 

type Variant_Uint64Value struct {
	// uint64Val:  A 64-bit unsigned integer.
	Uint64Value uint64 `idl:"name:uint64Val" json:"uint64_value"`
}

Variant_Uint64Value structure represents Variant_Variant RPC union arm.

It has following labels: 3

func (*Variant_Uint64Value) MarshalNDR 

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

func (*Variant_Uint64Value) UnmarshalNDR 

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

type Variant_Variant 

type Variant_Variant struct {
	// Types that are assignable to Value
	//
	// *Variant_NullValue
	// *Variant_BooleanValue
	// *Variant_Uint32Value
	// *Variant_Uint64Value
	// *Variant_StringValue
	// *Variant_GUIDValue
	// *Variant_BooleanArray
	// *Variant_Uint32Array
	// *Variant_Uint64Array
	// *Variant_StringArray
	// *Variant_GUIDArray
	Value is_Variant_Variant `json:"value"`
}

Variant_Variant structure represents EvtRpcVariant union anonymous member.

The EvtRpcVariant structure is defined as follows.

func (*Variant_Variant) GetValue 

func (o *Variant_Variant) GetValue() any

func (*Variant_Variant) MarshalUnionNDR 

func (o *Variant_Variant) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*Variant_Variant) NDRSwitchValue 

func (o *Variant_Variant) NDRSwitchValue(sw uint32) uint32

func (*Variant_Variant) UnmarshalUnionNDR 

func (o *Variant_Variant) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

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.