// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.34.1
// source: mxaccess_worker.proto

package generated

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type WorkerState int32

const (
	WorkerState_WORKER_STATE_UNSPECIFIED       WorkerState = 0
	WorkerState_WORKER_STATE_STARTING          WorkerState = 1
	WorkerState_WORKER_STATE_HANDSHAKING       WorkerState = 2
	WorkerState_WORKER_STATE_INITIALIZING_STA  WorkerState = 3
	WorkerState_WORKER_STATE_READY             WorkerState = 4
	WorkerState_WORKER_STATE_EXECUTING_COMMAND WorkerState = 5
	WorkerState_WORKER_STATE_SHUTTING_DOWN     WorkerState = 6
	WorkerState_WORKER_STATE_STOPPED           WorkerState = 7
	WorkerState_WORKER_STATE_FAULTED           WorkerState = 8
)

// Enum value maps for WorkerState.
var (
	WorkerState_name = map[int32]string{
		0: "WORKER_STATE_UNSPECIFIED",
		1: "WORKER_STATE_STARTING",
		2: "WORKER_STATE_HANDSHAKING",
		3: "WORKER_STATE_INITIALIZING_STA",
		4: "WORKER_STATE_READY",
		5: "WORKER_STATE_EXECUTING_COMMAND",
		6: "WORKER_STATE_SHUTTING_DOWN",
		7: "WORKER_STATE_STOPPED",
		8: "WORKER_STATE_FAULTED",
	}
	WorkerState_value = map[string]int32{
		"WORKER_STATE_UNSPECIFIED":       0,
		"WORKER_STATE_STARTING":          1,
		"WORKER_STATE_HANDSHAKING":       2,
		"WORKER_STATE_INITIALIZING_STA":  3,
		"WORKER_STATE_READY":             4,
		"WORKER_STATE_EXECUTING_COMMAND": 5,
		"WORKER_STATE_SHUTTING_DOWN":     6,
		"WORKER_STATE_STOPPED":           7,
		"WORKER_STATE_FAULTED":           8,
	}
)

func (x WorkerState) Enum() *WorkerState {
	p := new(WorkerState)
	*p = x
	return p
}

func (x WorkerState) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (WorkerState) Descriptor() protoreflect.EnumDescriptor {
	return file_mxaccess_worker_proto_enumTypes[0].Descriptor()
}

func (WorkerState) Type() protoreflect.EnumType {
	return &file_mxaccess_worker_proto_enumTypes[0]
}

func (x WorkerState) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use WorkerState.Descriptor instead.
func (WorkerState) EnumDescriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{0}
}

type WorkerFaultCategory int32

const (
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_UNSPECIFIED                      WorkerFaultCategory = 0
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_INVALID_ARGUMENTS                WorkerFaultCategory = 1
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_GATEWAY_AUTHENTICATION_FAILED    WorkerFaultCategory = 2
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_PROTOCOL_MISMATCH                WorkerFaultCategory = 3
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_PROTOCOL_VIOLATION               WorkerFaultCategory = 4
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_PIPE_DISCONNECTED                WorkerFaultCategory = 5
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_MXACCESS_CREATION_FAILED         WorkerFaultCategory = 6
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_MXACCESS_COMMAND_FAILED          WorkerFaultCategory = 7
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_MXACCESS_EVENT_CONVERSION_FAILED WorkerFaultCategory = 8
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_STA_HUNG                         WorkerFaultCategory = 9
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_QUEUE_OVERFLOW                   WorkerFaultCategory = 10
	WorkerFaultCategory_WORKER_FAULT_CATEGORY_SHUTDOWN_TIMEOUT                 WorkerFaultCategory = 11
)

// Enum value maps for WorkerFaultCategory.
var (
	WorkerFaultCategory_name = map[int32]string{
		0:  "WORKER_FAULT_CATEGORY_UNSPECIFIED",
		1:  "WORKER_FAULT_CATEGORY_INVALID_ARGUMENTS",
		2:  "WORKER_FAULT_CATEGORY_GATEWAY_AUTHENTICATION_FAILED",
		3:  "WORKER_FAULT_CATEGORY_PROTOCOL_MISMATCH",
		4:  "WORKER_FAULT_CATEGORY_PROTOCOL_VIOLATION",
		5:  "WORKER_FAULT_CATEGORY_PIPE_DISCONNECTED",
		6:  "WORKER_FAULT_CATEGORY_MXACCESS_CREATION_FAILED",
		7:  "WORKER_FAULT_CATEGORY_MXACCESS_COMMAND_FAILED",
		8:  "WORKER_FAULT_CATEGORY_MXACCESS_EVENT_CONVERSION_FAILED",
		9:  "WORKER_FAULT_CATEGORY_STA_HUNG",
		10: "WORKER_FAULT_CATEGORY_QUEUE_OVERFLOW",
		11: "WORKER_FAULT_CATEGORY_SHUTDOWN_TIMEOUT",
	}
	WorkerFaultCategory_value = map[string]int32{
		"WORKER_FAULT_CATEGORY_UNSPECIFIED":                      0,
		"WORKER_FAULT_CATEGORY_INVALID_ARGUMENTS":                1,
		"WORKER_FAULT_CATEGORY_GATEWAY_AUTHENTICATION_FAILED":    2,
		"WORKER_FAULT_CATEGORY_PROTOCOL_MISMATCH":                3,
		"WORKER_FAULT_CATEGORY_PROTOCOL_VIOLATION":               4,
		"WORKER_FAULT_CATEGORY_PIPE_DISCONNECTED":                5,
		"WORKER_FAULT_CATEGORY_MXACCESS_CREATION_FAILED":         6,
		"WORKER_FAULT_CATEGORY_MXACCESS_COMMAND_FAILED":          7,
		"WORKER_FAULT_CATEGORY_MXACCESS_EVENT_CONVERSION_FAILED": 8,
		"WORKER_FAULT_CATEGORY_STA_HUNG":                         9,
		"WORKER_FAULT_CATEGORY_QUEUE_OVERFLOW":                   10,
		"WORKER_FAULT_CATEGORY_SHUTDOWN_TIMEOUT":                 11,
	}
)

func (x WorkerFaultCategory) Enum() *WorkerFaultCategory {
	p := new(WorkerFaultCategory)
	*p = x
	return p
}

func (x WorkerFaultCategory) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (WorkerFaultCategory) Descriptor() protoreflect.EnumDescriptor {
	return file_mxaccess_worker_proto_enumTypes[1].Descriptor()
}

func (WorkerFaultCategory) Type() protoreflect.EnumType {
	return &file_mxaccess_worker_proto_enumTypes[1]
}

func (x WorkerFaultCategory) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use WorkerFaultCategory.Descriptor instead.
func (WorkerFaultCategory) EnumDescriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{1}
}

// Gateway-to-worker IPC envelope. Named-pipe framing prepends a little-endian
// uint32 payload length to this protobuf payload.
type WorkerEnvelope struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	ProtocolVersion uint32                 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	SessionId       string                 `protobuf:"bytes,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	Sequence        uint64                 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`
	CorrelationId   string                 `protobuf:"bytes,4,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
	// Types that are valid to be assigned to Body:
	//
	//	*WorkerEnvelope_GatewayHello
	//	*WorkerEnvelope_WorkerHello
	//	*WorkerEnvelope_WorkerReady
	//	*WorkerEnvelope_WorkerCommand
	//	*WorkerEnvelope_WorkerCommandReply
	//	*WorkerEnvelope_WorkerCancel
	//	*WorkerEnvelope_WorkerShutdown
	//	*WorkerEnvelope_WorkerShutdownAck
	//	*WorkerEnvelope_WorkerEvent
	//	*WorkerEnvelope_WorkerHeartbeat
	//	*WorkerEnvelope_WorkerFault
	Body          isWorkerEnvelope_Body `protobuf_oneof:"body"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WorkerEnvelope) Reset() {
	*x = WorkerEnvelope{}
	mi := &file_mxaccess_worker_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerEnvelope) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerEnvelope) ProtoMessage() {}

func (x *WorkerEnvelope) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerEnvelope.ProtoReflect.Descriptor instead.
func (*WorkerEnvelope) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{0}
}

func (x *WorkerEnvelope) GetProtocolVersion() uint32 {
	if x != nil {
		return x.ProtocolVersion
	}
	return 0
}

func (x *WorkerEnvelope) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *WorkerEnvelope) GetSequence() uint64 {
	if x != nil {
		return x.Sequence
	}
	return 0
}

func (x *WorkerEnvelope) GetCorrelationId() string {
	if x != nil {
		return x.CorrelationId
	}
	return ""
}

func (x *WorkerEnvelope) GetBody() isWorkerEnvelope_Body {
	if x != nil {
		return x.Body
	}
	return nil
}

func (x *WorkerEnvelope) GetGatewayHello() *GatewayHello {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_GatewayHello); ok {
			return x.GatewayHello
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerHello() *WorkerHello {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerHello); ok {
			return x.WorkerHello
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerReady() *WorkerReady {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerReady); ok {
			return x.WorkerReady
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerCommand() *WorkerCommand {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerCommand); ok {
			return x.WorkerCommand
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerCommandReply() *WorkerCommandReply {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerCommandReply); ok {
			return x.WorkerCommandReply
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerCancel() *WorkerCancel {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerCancel); ok {
			return x.WorkerCancel
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerShutdown() *WorkerShutdown {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerShutdown); ok {
			return x.WorkerShutdown
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerShutdownAck() *WorkerShutdownAck {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerShutdownAck); ok {
			return x.WorkerShutdownAck
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerEvent() *WorkerEvent {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerEvent); ok {
			return x.WorkerEvent
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerHeartbeat() *WorkerHeartbeat {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerHeartbeat); ok {
			return x.WorkerHeartbeat
		}
	}
	return nil
}

func (x *WorkerEnvelope) GetWorkerFault() *WorkerFault {
	if x != nil {
		if x, ok := x.Body.(*WorkerEnvelope_WorkerFault); ok {
			return x.WorkerFault
		}
	}
	return nil
}

type isWorkerEnvelope_Body interface {
	isWorkerEnvelope_Body()
}

type WorkerEnvelope_GatewayHello struct {
	GatewayHello *GatewayHello `protobuf:"bytes,10,opt,name=gateway_hello,json=gatewayHello,proto3,oneof"`
}

type WorkerEnvelope_WorkerHello struct {
	WorkerHello *WorkerHello `protobuf:"bytes,11,opt,name=worker_hello,json=workerHello,proto3,oneof"`
}

type WorkerEnvelope_WorkerReady struct {
	WorkerReady *WorkerReady `protobuf:"bytes,12,opt,name=worker_ready,json=workerReady,proto3,oneof"`
}

type WorkerEnvelope_WorkerCommand struct {
	WorkerCommand *WorkerCommand `protobuf:"bytes,13,opt,name=worker_command,json=workerCommand,proto3,oneof"`
}

type WorkerEnvelope_WorkerCommandReply struct {
	WorkerCommandReply *WorkerCommandReply `protobuf:"bytes,14,opt,name=worker_command_reply,json=workerCommandReply,proto3,oneof"`
}

type WorkerEnvelope_WorkerCancel struct {
	WorkerCancel *WorkerCancel `protobuf:"bytes,15,opt,name=worker_cancel,json=workerCancel,proto3,oneof"`
}

type WorkerEnvelope_WorkerShutdown struct {
	WorkerShutdown *WorkerShutdown `protobuf:"bytes,16,opt,name=worker_shutdown,json=workerShutdown,proto3,oneof"`
}

type WorkerEnvelope_WorkerShutdownAck struct {
	WorkerShutdownAck *WorkerShutdownAck `protobuf:"bytes,17,opt,name=worker_shutdown_ack,json=workerShutdownAck,proto3,oneof"`
}

type WorkerEnvelope_WorkerEvent struct {
	WorkerEvent *WorkerEvent `protobuf:"bytes,18,opt,name=worker_event,json=workerEvent,proto3,oneof"`
}

type WorkerEnvelope_WorkerHeartbeat struct {
	WorkerHeartbeat *WorkerHeartbeat `protobuf:"bytes,19,opt,name=worker_heartbeat,json=workerHeartbeat,proto3,oneof"`
}

type WorkerEnvelope_WorkerFault struct {
	WorkerFault *WorkerFault `protobuf:"bytes,20,opt,name=worker_fault,json=workerFault,proto3,oneof"`
}

func (*WorkerEnvelope_GatewayHello) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerHello) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerReady) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerCommand) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerCommandReply) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerCancel) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerShutdown) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerShutdownAck) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerEvent) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerHeartbeat) isWorkerEnvelope_Body() {}

func (*WorkerEnvelope_WorkerFault) isWorkerEnvelope_Body() {}

type GatewayHello struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	SupportedProtocolVersion uint32                 `protobuf:"varint,1,opt,name=supported_protocol_version,json=supportedProtocolVersion,proto3" json:"supported_protocol_version,omitempty"`
	Nonce                    string                 `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	GatewayVersion           string                 `protobuf:"bytes,3,opt,name=gateway_version,json=gatewayVersion,proto3" json:"gateway_version,omitempty"`
	// Maximum worker-frame payload size, in bytes, negotiated by the gateway from its
	// configured pipe limit. The worker adopts this as its frame-protocol MaxMessageBytes
	// instead of a hard-coded default; 0 (an older gateway that never set the field) means
	// "use the worker's built-in default". Sits above the public gRPC cap by an
	// envelope-overhead margin so an accepted gRPC payload always fits one worker frame.
	// Every worker->gateway frame — events, heartbeats, faults, and control replies
	// including DrainEvents — must serialize within this limit; reply builders truncate
	// to fit rather than emit an oversized frame.
	MaxFrameBytes uint32 `protobuf:"varint,4,opt,name=max_frame_bytes,json=maxFrameBytes,proto3" json:"max_frame_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GatewayHello) Reset() {
	*x = GatewayHello{}
	mi := &file_mxaccess_worker_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GatewayHello) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GatewayHello) ProtoMessage() {}

func (x *GatewayHello) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GatewayHello.ProtoReflect.Descriptor instead.
func (*GatewayHello) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{1}
}

func (x *GatewayHello) GetSupportedProtocolVersion() uint32 {
	if x != nil {
		return x.SupportedProtocolVersion
	}
	return 0
}

func (x *GatewayHello) GetNonce() string {
	if x != nil {
		return x.Nonce
	}
	return ""
}

func (x *GatewayHello) GetGatewayVersion() string {
	if x != nil {
		return x.GatewayVersion
	}
	return ""
}

func (x *GatewayHello) GetMaxFrameBytes() uint32 {
	if x != nil {
		return x.MaxFrameBytes
	}
	return 0
}

type WorkerHello struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	ProtocolVersion uint32                 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	Nonce           string                 `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	WorkerProcessId int32                  `protobuf:"varint,3,opt,name=worker_process_id,json=workerProcessId,proto3" json:"worker_process_id,omitempty"`
	WorkerVersion   string                 `protobuf:"bytes,4,opt,name=worker_version,json=workerVersion,proto3" json:"worker_version,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *WorkerHello) Reset() {
	*x = WorkerHello{}
	mi := &file_mxaccess_worker_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerHello) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerHello) ProtoMessage() {}

func (x *WorkerHello) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerHello.ProtoReflect.Descriptor instead.
func (*WorkerHello) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{2}
}

func (x *WorkerHello) GetProtocolVersion() uint32 {
	if x != nil {
		return x.ProtocolVersion
	}
	return 0
}

func (x *WorkerHello) GetNonce() string {
	if x != nil {
		return x.Nonce
	}
	return ""
}

func (x *WorkerHello) GetWorkerProcessId() int32 {
	if x != nil {
		return x.WorkerProcessId
	}
	return 0
}

func (x *WorkerHello) GetWorkerVersion() string {
	if x != nil {
		return x.WorkerVersion
	}
	return ""
}

type WorkerReady struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	WorkerProcessId int32                  `protobuf:"varint,1,opt,name=worker_process_id,json=workerProcessId,proto3" json:"worker_process_id,omitempty"`
	MxaccessProgid  string                 `protobuf:"bytes,2,opt,name=mxaccess_progid,json=mxaccessProgid,proto3" json:"mxaccess_progid,omitempty"`
	MxaccessClsid   string                 `protobuf:"bytes,3,opt,name=mxaccess_clsid,json=mxaccessClsid,proto3" json:"mxaccess_clsid,omitempty"`
	ReadyTimestamp  *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=ready_timestamp,json=readyTimestamp,proto3" json:"ready_timestamp,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *WorkerReady) Reset() {
	*x = WorkerReady{}
	mi := &file_mxaccess_worker_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerReady) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerReady) ProtoMessage() {}

func (x *WorkerReady) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerReady.ProtoReflect.Descriptor instead.
func (*WorkerReady) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{3}
}

func (x *WorkerReady) GetWorkerProcessId() int32 {
	if x != nil {
		return x.WorkerProcessId
	}
	return 0
}

func (x *WorkerReady) GetMxaccessProgid() string {
	if x != nil {
		return x.MxaccessProgid
	}
	return ""
}

func (x *WorkerReady) GetMxaccessClsid() string {
	if x != nil {
		return x.MxaccessClsid
	}
	return ""
}

func (x *WorkerReady) GetReadyTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.ReadyTimestamp
	}
	return nil
}

type WorkerCommand struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Command          *MxCommand             `protobuf:"bytes,1,opt,name=command,proto3" json:"command,omitempty"`
	EnqueueTimestamp *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=enqueue_timestamp,json=enqueueTimestamp,proto3" json:"enqueue_timestamp,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *WorkerCommand) Reset() {
	*x = WorkerCommand{}
	mi := &file_mxaccess_worker_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerCommand) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerCommand) ProtoMessage() {}

func (x *WorkerCommand) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerCommand.ProtoReflect.Descriptor instead.
func (*WorkerCommand) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{4}
}

func (x *WorkerCommand) GetCommand() *MxCommand {
	if x != nil {
		return x.Command
	}
	return nil
}

func (x *WorkerCommand) GetEnqueueTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.EnqueueTimestamp
	}
	return nil
}

type WorkerCommandReply struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	Reply              *MxCommandReply        `protobuf:"bytes,1,opt,name=reply,proto3" json:"reply,omitempty"`
	CompletedTimestamp *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=completed_timestamp,json=completedTimestamp,proto3" json:"completed_timestamp,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *WorkerCommandReply) Reset() {
	*x = WorkerCommandReply{}
	mi := &file_mxaccess_worker_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerCommandReply) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerCommandReply) ProtoMessage() {}

func (x *WorkerCommandReply) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerCommandReply.ProtoReflect.Descriptor instead.
func (*WorkerCommandReply) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{5}
}

func (x *WorkerCommandReply) GetReply() *MxCommandReply {
	if x != nil {
		return x.Reply
	}
	return nil
}

func (x *WorkerCommandReply) GetCompletedTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.CompletedTimestamp
	}
	return nil
}

type WorkerCancel struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Reason        string                 `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WorkerCancel) Reset() {
	*x = WorkerCancel{}
	mi := &file_mxaccess_worker_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerCancel) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerCancel) ProtoMessage() {}

func (x *WorkerCancel) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerCancel.ProtoReflect.Descriptor instead.
func (*WorkerCancel) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{6}
}

func (x *WorkerCancel) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type WorkerShutdown struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	GracePeriod   *durationpb.Duration   `protobuf:"bytes,1,opt,name=grace_period,json=gracePeriod,proto3" json:"grace_period,omitempty"`
	Reason        string                 `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WorkerShutdown) Reset() {
	*x = WorkerShutdown{}
	mi := &file_mxaccess_worker_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerShutdown) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerShutdown) ProtoMessage() {}

func (x *WorkerShutdown) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerShutdown.ProtoReflect.Descriptor instead.
func (*WorkerShutdown) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{7}
}

func (x *WorkerShutdown) GetGracePeriod() *durationpb.Duration {
	if x != nil {
		return x.GracePeriod
	}
	return nil
}

func (x *WorkerShutdown) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type WorkerShutdownAck struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *ProtocolStatus        `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WorkerShutdownAck) Reset() {
	*x = WorkerShutdownAck{}
	mi := &file_mxaccess_worker_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerShutdownAck) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerShutdownAck) ProtoMessage() {}

func (x *WorkerShutdownAck) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerShutdownAck.ProtoReflect.Descriptor instead.
func (*WorkerShutdownAck) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{8}
}

func (x *WorkerShutdownAck) GetStatus() *ProtocolStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

type WorkerEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Event         *MxEvent               `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WorkerEvent) Reset() {
	*x = WorkerEvent{}
	mi := &file_mxaccess_worker_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerEvent) ProtoMessage() {}

func (x *WorkerEvent) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerEvent.ProtoReflect.Descriptor instead.
func (*WorkerEvent) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{9}
}

func (x *WorkerEvent) GetEvent() *MxEvent {
	if x != nil {
		return x.Event
	}
	return nil
}

type WorkerHeartbeat struct {
	state                       protoimpl.MessageState `protogen:"open.v1"`
	WorkerProcessId             int32                  `protobuf:"varint,1,opt,name=worker_process_id,json=workerProcessId,proto3" json:"worker_process_id,omitempty"`
	State                       WorkerState            `protobuf:"varint,2,opt,name=state,proto3,enum=mxaccess_worker.v1.WorkerState" json:"state,omitempty"`
	LastStaActivityTimestamp    *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=last_sta_activity_timestamp,json=lastStaActivityTimestamp,proto3" json:"last_sta_activity_timestamp,omitempty"`
	PendingCommandCount         uint32                 `protobuf:"varint,4,opt,name=pending_command_count,json=pendingCommandCount,proto3" json:"pending_command_count,omitempty"`
	OutboundEventQueueDepth     uint32                 `protobuf:"varint,5,opt,name=outbound_event_queue_depth,json=outboundEventQueueDepth,proto3" json:"outbound_event_queue_depth,omitempty"`
	LastEventSequence           uint64                 `protobuf:"varint,6,opt,name=last_event_sequence,json=lastEventSequence,proto3" json:"last_event_sequence,omitempty"`
	CurrentCommandCorrelationId string                 `protobuf:"bytes,7,opt,name=current_command_correlation_id,json=currentCommandCorrelationId,proto3" json:"current_command_correlation_id,omitempty"`
	unknownFields               protoimpl.UnknownFields
	sizeCache                   protoimpl.SizeCache
}

func (x *WorkerHeartbeat) Reset() {
	*x = WorkerHeartbeat{}
	mi := &file_mxaccess_worker_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerHeartbeat) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerHeartbeat) ProtoMessage() {}

func (x *WorkerHeartbeat) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerHeartbeat.ProtoReflect.Descriptor instead.
func (*WorkerHeartbeat) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{10}
}

func (x *WorkerHeartbeat) GetWorkerProcessId() int32 {
	if x != nil {
		return x.WorkerProcessId
	}
	return 0
}

func (x *WorkerHeartbeat) GetState() WorkerState {
	if x != nil {
		return x.State
	}
	return WorkerState_WORKER_STATE_UNSPECIFIED
}

func (x *WorkerHeartbeat) GetLastStaActivityTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.LastStaActivityTimestamp
	}
	return nil
}

func (x *WorkerHeartbeat) GetPendingCommandCount() uint32 {
	if x != nil {
		return x.PendingCommandCount
	}
	return 0
}

func (x *WorkerHeartbeat) GetOutboundEventQueueDepth() uint32 {
	if x != nil {
		return x.OutboundEventQueueDepth
	}
	return 0
}

func (x *WorkerHeartbeat) GetLastEventSequence() uint64 {
	if x != nil {
		return x.LastEventSequence
	}
	return 0
}

func (x *WorkerHeartbeat) GetCurrentCommandCorrelationId() string {
	if x != nil {
		return x.CurrentCommandCorrelationId
	}
	return ""
}

type WorkerFault struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	Category          WorkerFaultCategory    `protobuf:"varint,1,opt,name=category,proto3,enum=mxaccess_worker.v1.WorkerFaultCategory" json:"category,omitempty"`
	CommandMethod     string                 `protobuf:"bytes,2,opt,name=command_method,json=commandMethod,proto3" json:"command_method,omitempty"`
	Hresult           *int32                 `protobuf:"varint,3,opt,name=hresult,proto3,oneof" json:"hresult,omitempty"`
	ExceptionType     string                 `protobuf:"bytes,4,opt,name=exception_type,json=exceptionType,proto3" json:"exception_type,omitempty"`
	DiagnosticMessage string                 `protobuf:"bytes,5,opt,name=diagnostic_message,json=diagnosticMessage,proto3" json:"diagnostic_message,omitempty"`
	ProtocolStatus    *ProtocolStatus        `protobuf:"bytes,6,opt,name=protocol_status,json=protocolStatus,proto3" json:"protocol_status,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *WorkerFault) Reset() {
	*x = WorkerFault{}
	mi := &file_mxaccess_worker_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WorkerFault) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WorkerFault) ProtoMessage() {}

func (x *WorkerFault) ProtoReflect() protoreflect.Message {
	mi := &file_mxaccess_worker_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkerFault.ProtoReflect.Descriptor instead.
func (*WorkerFault) Descriptor() ([]byte, []int) {
	return file_mxaccess_worker_proto_rawDescGZIP(), []int{11}
}

func (x *WorkerFault) GetCategory() WorkerFaultCategory {
	if x != nil {
		return x.Category
	}
	return WorkerFaultCategory_WORKER_FAULT_CATEGORY_UNSPECIFIED
}

func (x *WorkerFault) GetCommandMethod() string {
	if x != nil {
		return x.CommandMethod
	}
	return ""
}

func (x *WorkerFault) GetHresult() int32 {
	if x != nil && x.Hresult != nil {
		return *x.Hresult
	}
	return 0
}

func (x *WorkerFault) GetExceptionType() string {
	if x != nil {
		return x.ExceptionType
	}
	return ""
}

func (x *WorkerFault) GetDiagnosticMessage() string {
	if x != nil {
		return x.DiagnosticMessage
	}
	return ""
}

func (x *WorkerFault) GetProtocolStatus() *ProtocolStatus {
	if x != nil {
		return x.ProtocolStatus
	}
	return nil
}

var File_mxaccess_worker_proto protoreflect.FileDescriptor

const file_mxaccess_worker_proto_rawDesc = "" +
	"\n" +
	"\x15mxaccess_worker.proto\x12\x12mxaccess_worker.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x16mxaccess_gateway.proto\"\xf1\a\n" +
	"\x0eWorkerEnvelope\x12)\n" +
	"\x10protocol_version\x18\x01 \x01(\rR\x0fprotocolVersion\x12\x1d\n" +
	"\n" +
	"session_id\x18\x02 \x01(\tR\tsessionId\x12\x1a\n" +
	"\bsequence\x18\x03 \x01(\x04R\bsequence\x12%\n" +
	"\x0ecorrelation_id\x18\x04 \x01(\tR\rcorrelationId\x12G\n" +
	"\rgateway_hello\x18\n" +
	" \x01(\v2 .mxaccess_worker.v1.GatewayHelloH\x00R\fgatewayHello\x12D\n" +
	"\fworker_hello\x18\v \x01(\v2\x1f.mxaccess_worker.v1.WorkerHelloH\x00R\vworkerHello\x12D\n" +
	"\fworker_ready\x18\f \x01(\v2\x1f.mxaccess_worker.v1.WorkerReadyH\x00R\vworkerReady\x12J\n" +
	"\x0eworker_command\x18\r \x01(\v2!.mxaccess_worker.v1.WorkerCommandH\x00R\rworkerCommand\x12Z\n" +
	"\x14worker_command_reply\x18\x0e \x01(\v2&.mxaccess_worker.v1.WorkerCommandReplyH\x00R\x12workerCommandReply\x12G\n" +
	"\rworker_cancel\x18\x0f \x01(\v2 .mxaccess_worker.v1.WorkerCancelH\x00R\fworkerCancel\x12M\n" +
	"\x0fworker_shutdown\x18\x10 \x01(\v2\".mxaccess_worker.v1.WorkerShutdownH\x00R\x0eworkerShutdown\x12W\n" +
	"\x13worker_shutdown_ack\x18\x11 \x01(\v2%.mxaccess_worker.v1.WorkerShutdownAckH\x00R\x11workerShutdownAck\x12D\n" +
	"\fworker_event\x18\x12 \x01(\v2\x1f.mxaccess_worker.v1.WorkerEventH\x00R\vworkerEvent\x12P\n" +
	"\x10worker_heartbeat\x18\x13 \x01(\v2#.mxaccess_worker.v1.WorkerHeartbeatH\x00R\x0fworkerHeartbeat\x12D\n" +
	"\fworker_fault\x18\x14 \x01(\v2\x1f.mxaccess_worker.v1.WorkerFaultH\x00R\vworkerFaultB\x06\n" +
	"\x04body\"\xb3\x01\n" +
	"\fGatewayHello\x12<\n" +
	"\x1asupported_protocol_version\x18\x01 \x01(\rR\x18supportedProtocolVersion\x12\x14\n" +
	"\x05nonce\x18\x02 \x01(\tR\x05nonce\x12'\n" +
	"\x0fgateway_version\x18\x03 \x01(\tR\x0egatewayVersion\x12&\n" +
	"\x0fmax_frame_bytes\x18\x04 \x01(\rR\rmaxFrameBytes\"\xa1\x01\n" +
	"\vWorkerHello\x12)\n" +
	"\x10protocol_version\x18\x01 \x01(\rR\x0fprotocolVersion\x12\x14\n" +
	"\x05nonce\x18\x02 \x01(\tR\x05nonce\x12*\n" +
	"\x11worker_process_id\x18\x03 \x01(\x05R\x0fworkerProcessId\x12%\n" +
	"\x0eworker_version\x18\x04 \x01(\tR\rworkerVersion\"\xce\x01\n" +
	"\vWorkerReady\x12*\n" +
	"\x11worker_process_id\x18\x01 \x01(\x05R\x0fworkerProcessId\x12'\n" +
	"\x0fmxaccess_progid\x18\x02 \x01(\tR\x0emxaccessProgid\x12%\n" +
	"\x0emxaccess_clsid\x18\x03 \x01(\tR\rmxaccessClsid\x12C\n" +
	"\x0fready_timestamp\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\x0ereadyTimestamp\"\x92\x01\n" +
	"\rWorkerCommand\x128\n" +
	"\acommand\x18\x01 \x01(\v2\x1e.mxaccess_gateway.v1.MxCommandR\acommand\x12G\n" +
	"\x11enqueue_timestamp\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x10enqueueTimestamp\"\x9c\x01\n" +
	"\x12WorkerCommandReply\x129\n" +
	"\x05reply\x18\x01 \x01(\v2#.mxaccess_gateway.v1.MxCommandReplyR\x05reply\x12K\n" +
	"\x13completed_timestamp\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x12completedTimestamp\"&\n" +
	"\fWorkerCancel\x12\x16\n" +
	"\x06reason\x18\x01 \x01(\tR\x06reason\"f\n" +
	"\x0eWorkerShutdown\x12<\n" +
	"\fgrace_period\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\vgracePeriod\x12\x16\n" +
	"\x06reason\x18\x02 \x01(\tR\x06reason\"P\n" +
	"\x11WorkerShutdownAck\x12;\n" +
	"\x06status\x18\x01 \x01(\v2#.mxaccess_gateway.v1.ProtocolStatusR\x06status\"A\n" +
	"\vWorkerEvent\x122\n" +
	"\x05event\x18\x01 \x01(\v2\x1c.mxaccess_gateway.v1.MxEventR\x05event\"\xb5\x03\n" +
	"\x0fWorkerHeartbeat\x12*\n" +
	"\x11worker_process_id\x18\x01 \x01(\x05R\x0fworkerProcessId\x125\n" +
	"\x05state\x18\x02 \x01(\x0e2\x1f.mxaccess_worker.v1.WorkerStateR\x05state\x12Y\n" +
	"\x1blast_sta_activity_timestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x18lastStaActivityTimestamp\x122\n" +
	"\x15pending_command_count\x18\x04 \x01(\rR\x13pendingCommandCount\x12;\n" +
	"\x1aoutbound_event_queue_depth\x18\x05 \x01(\rR\x17outboundEventQueueDepth\x12.\n" +
	"\x13last_event_sequence\x18\x06 \x01(\x04R\x11lastEventSequence\x12C\n" +
	"\x1ecurrent_command_correlation_id\x18\a \x01(\tR\x1bcurrentCommandCorrelationId\"\xc8\x02\n" +
	"\vWorkerFault\x12C\n" +
	"\bcategory\x18\x01 \x01(\x0e2'.mxaccess_worker.v1.WorkerFaultCategoryR\bcategory\x12%\n" +
	"\x0ecommand_method\x18\x02 \x01(\tR\rcommandMethod\x12\x1d\n" +
	"\ahresult\x18\x03 \x01(\x05H\x00R\ahresult\x88\x01\x01\x12%\n" +
	"\x0eexception_type\x18\x04 \x01(\tR\rexceptionType\x12-\n" +
	"\x12diagnostic_message\x18\x05 \x01(\tR\x11diagnosticMessage\x12L\n" +
	"\x0fprotocol_status\x18\x06 \x01(\v2#.mxaccess_gateway.v1.ProtocolStatusR\x0eprotocolStatusB\n" +
	"\n" +
	"\b_hresult*\x97\x02\n" +
	"\vWorkerState\x12\x1c\n" +
	"\x18WORKER_STATE_UNSPECIFIED\x10\x00\x12\x19\n" +
	"\x15WORKER_STATE_STARTING\x10\x01\x12\x1c\n" +
	"\x18WORKER_STATE_HANDSHAKING\x10\x02\x12!\n" +
	"\x1dWORKER_STATE_INITIALIZING_STA\x10\x03\x12\x16\n" +
	"\x12WORKER_STATE_READY\x10\x04\x12\"\n" +
	"\x1eWORKER_STATE_EXECUTING_COMMAND\x10\x05\x12\x1e\n" +
	"\x1aWORKER_STATE_SHUTTING_DOWN\x10\x06\x12\x18\n" +
	"\x14WORKER_STATE_STOPPED\x10\a\x12\x18\n" +
	"\x14WORKER_STATE_FAULTED\x10\b*\xc7\x04\n" +
	"\x13WorkerFaultCategory\x12%\n" +
	"!WORKER_FAULT_CATEGORY_UNSPECIFIED\x10\x00\x12+\n" +
	"'WORKER_FAULT_CATEGORY_INVALID_ARGUMENTS\x10\x01\x127\n" +
	"3WORKER_FAULT_CATEGORY_GATEWAY_AUTHENTICATION_FAILED\x10\x02\x12+\n" +
	"'WORKER_FAULT_CATEGORY_PROTOCOL_MISMATCH\x10\x03\x12,\n" +
	"(WORKER_FAULT_CATEGORY_PROTOCOL_VIOLATION\x10\x04\x12+\n" +
	"'WORKER_FAULT_CATEGORY_PIPE_DISCONNECTED\x10\x05\x122\n" +
	".WORKER_FAULT_CATEGORY_MXACCESS_CREATION_FAILED\x10\x06\x121\n" +
	"-WORKER_FAULT_CATEGORY_MXACCESS_COMMAND_FAILED\x10\a\x12:\n" +
	"6WORKER_FAULT_CATEGORY_MXACCESS_EVENT_CONVERSION_FAILED\x10\b\x12\"\n" +
	"\x1eWORKER_FAULT_CATEGORY_STA_HUNG\x10\t\x12(\n" +
	"$WORKER_FAULT_CATEGORY_QUEUE_OVERFLOW\x10\n" +
	"\x12*\n" +
	"&WORKER_FAULT_CATEGORY_SHUTDOWN_TIMEOUT\x10\vB&\xaa\x02#ZB.MOM.WW.MxGateway.Contracts.Protob\x06proto3"

var (
	file_mxaccess_worker_proto_rawDescOnce sync.Once
	file_mxaccess_worker_proto_rawDescData []byte
)

func file_mxaccess_worker_proto_rawDescGZIP() []byte {
	file_mxaccess_worker_proto_rawDescOnce.Do(func() {
		file_mxaccess_worker_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_mxaccess_worker_proto_rawDesc), len(file_mxaccess_worker_proto_rawDesc)))
	})
	return file_mxaccess_worker_proto_rawDescData
}

var file_mxaccess_worker_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_mxaccess_worker_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_mxaccess_worker_proto_goTypes = []any{
	(WorkerState)(0),              // 0: mxaccess_worker.v1.WorkerState
	(WorkerFaultCategory)(0),      // 1: mxaccess_worker.v1.WorkerFaultCategory
	(*WorkerEnvelope)(nil),        // 2: mxaccess_worker.v1.WorkerEnvelope
	(*GatewayHello)(nil),          // 3: mxaccess_worker.v1.GatewayHello
	(*WorkerHello)(nil),           // 4: mxaccess_worker.v1.WorkerHello
	(*WorkerReady)(nil),           // 5: mxaccess_worker.v1.WorkerReady
	(*WorkerCommand)(nil),         // 6: mxaccess_worker.v1.WorkerCommand
	(*WorkerCommandReply)(nil),    // 7: mxaccess_worker.v1.WorkerCommandReply
	(*WorkerCancel)(nil),          // 8: mxaccess_worker.v1.WorkerCancel
	(*WorkerShutdown)(nil),        // 9: mxaccess_worker.v1.WorkerShutdown
	(*WorkerShutdownAck)(nil),     // 10: mxaccess_worker.v1.WorkerShutdownAck
	(*WorkerEvent)(nil),           // 11: mxaccess_worker.v1.WorkerEvent
	(*WorkerHeartbeat)(nil),       // 12: mxaccess_worker.v1.WorkerHeartbeat
	(*WorkerFault)(nil),           // 13: mxaccess_worker.v1.WorkerFault
	(*timestamppb.Timestamp)(nil), // 14: google.protobuf.Timestamp
	(*MxCommand)(nil),             // 15: mxaccess_gateway.v1.MxCommand
	(*MxCommandReply)(nil),        // 16: mxaccess_gateway.v1.MxCommandReply
	(*durationpb.Duration)(nil),   // 17: google.protobuf.Duration
	(*ProtocolStatus)(nil),        // 18: mxaccess_gateway.v1.ProtocolStatus
	(*MxEvent)(nil),               // 19: mxaccess_gateway.v1.MxEvent
}
var file_mxaccess_worker_proto_depIdxs = []int32{
	3,  // 0: mxaccess_worker.v1.WorkerEnvelope.gateway_hello:type_name -> mxaccess_worker.v1.GatewayHello
	4,  // 1: mxaccess_worker.v1.WorkerEnvelope.worker_hello:type_name -> mxaccess_worker.v1.WorkerHello
	5,  // 2: mxaccess_worker.v1.WorkerEnvelope.worker_ready:type_name -> mxaccess_worker.v1.WorkerReady
	6,  // 3: mxaccess_worker.v1.WorkerEnvelope.worker_command:type_name -> mxaccess_worker.v1.WorkerCommand
	7,  // 4: mxaccess_worker.v1.WorkerEnvelope.worker_command_reply:type_name -> mxaccess_worker.v1.WorkerCommandReply
	8,  // 5: mxaccess_worker.v1.WorkerEnvelope.worker_cancel:type_name -> mxaccess_worker.v1.WorkerCancel
	9,  // 6: mxaccess_worker.v1.WorkerEnvelope.worker_shutdown:type_name -> mxaccess_worker.v1.WorkerShutdown
	10, // 7: mxaccess_worker.v1.WorkerEnvelope.worker_shutdown_ack:type_name -> mxaccess_worker.v1.WorkerShutdownAck
	11, // 8: mxaccess_worker.v1.WorkerEnvelope.worker_event:type_name -> mxaccess_worker.v1.WorkerEvent
	12, // 9: mxaccess_worker.v1.WorkerEnvelope.worker_heartbeat:type_name -> mxaccess_worker.v1.WorkerHeartbeat
	13, // 10: mxaccess_worker.v1.WorkerEnvelope.worker_fault:type_name -> mxaccess_worker.v1.WorkerFault
	14, // 11: mxaccess_worker.v1.WorkerReady.ready_timestamp:type_name -> google.protobuf.Timestamp
	15, // 12: mxaccess_worker.v1.WorkerCommand.command:type_name -> mxaccess_gateway.v1.MxCommand
	14, // 13: mxaccess_worker.v1.WorkerCommand.enqueue_timestamp:type_name -> google.protobuf.Timestamp
	16, // 14: mxaccess_worker.v1.WorkerCommandReply.reply:type_name -> mxaccess_gateway.v1.MxCommandReply
	14, // 15: mxaccess_worker.v1.WorkerCommandReply.completed_timestamp:type_name -> google.protobuf.Timestamp
	17, // 16: mxaccess_worker.v1.WorkerShutdown.grace_period:type_name -> google.protobuf.Duration
	18, // 17: mxaccess_worker.v1.WorkerShutdownAck.status:type_name -> mxaccess_gateway.v1.ProtocolStatus
	19, // 18: mxaccess_worker.v1.WorkerEvent.event:type_name -> mxaccess_gateway.v1.MxEvent
	0,  // 19: mxaccess_worker.v1.WorkerHeartbeat.state:type_name -> mxaccess_worker.v1.WorkerState
	14, // 20: mxaccess_worker.v1.WorkerHeartbeat.last_sta_activity_timestamp:type_name -> google.protobuf.Timestamp
	1,  // 21: mxaccess_worker.v1.WorkerFault.category:type_name -> mxaccess_worker.v1.WorkerFaultCategory
	18, // 22: mxaccess_worker.v1.WorkerFault.protocol_status:type_name -> mxaccess_gateway.v1.ProtocolStatus
	23, // [23:23] is the sub-list for method output_type
	23, // [23:23] is the sub-list for method input_type
	23, // [23:23] is the sub-list for extension type_name
	23, // [23:23] is the sub-list for extension extendee
	0,  // [0:23] is the sub-list for field type_name
}

func init() { file_mxaccess_worker_proto_init() }
func file_mxaccess_worker_proto_init() {
	if File_mxaccess_worker_proto != nil {
		return
	}
	file_mxaccess_gateway_proto_init()
	file_mxaccess_worker_proto_msgTypes[0].OneofWrappers = []any{
		(*WorkerEnvelope_GatewayHello)(nil),
		(*WorkerEnvelope_WorkerHello)(nil),
		(*WorkerEnvelope_WorkerReady)(nil),
		(*WorkerEnvelope_WorkerCommand)(nil),
		(*WorkerEnvelope_WorkerCommandReply)(nil),
		(*WorkerEnvelope_WorkerCancel)(nil),
		(*WorkerEnvelope_WorkerShutdown)(nil),
		(*WorkerEnvelope_WorkerShutdownAck)(nil),
		(*WorkerEnvelope_WorkerEvent)(nil),
		(*WorkerEnvelope_WorkerHeartbeat)(nil),
		(*WorkerEnvelope_WorkerFault)(nil),
	}
	file_mxaccess_worker_proto_msgTypes[11].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_mxaccess_worker_proto_rawDesc), len(file_mxaccess_worker_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_mxaccess_worker_proto_goTypes,
		DependencyIndexes: file_mxaccess_worker_proto_depIdxs,
		EnumInfos:         file_mxaccess_worker_proto_enumTypes,
		MessageInfos:      file_mxaccess_worker_proto_msgTypes,
	}.Build()
	File_mxaccess_worker_proto = out.File
	file_mxaccess_worker_proto_goTypes = nil
	file_mxaccess_worker_proto_depIdxs = nil
}
