// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.7
// 	protoc        v3.21.12
// source: remote.proto

package remote

import (
	actor "github.com/asynkron/protoactor-go/actor"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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 ListProcessesMatchType int32

const (
	ListProcessesMatchType_MatchPartOfString ListProcessesMatchType = 0
	ListProcessesMatchType_MatchExactString  ListProcessesMatchType = 1
	ListProcessesMatchType_MatchRegex        ListProcessesMatchType = 2
)

// Enum value maps for ListProcessesMatchType.
var (
	ListProcessesMatchType_name = map[int32]string{
		0: "MatchPartOfString",
		1: "MatchExactString",
		2: "MatchRegex",
	}
	ListProcessesMatchType_value = map[string]int32{
		"MatchPartOfString": 0,
		"MatchExactString":  1,
		"MatchRegex":        2,
	}
)

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

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

func (ListProcessesMatchType) Descriptor() protoreflect.EnumDescriptor {
	return file_remote_proto_enumTypes[0].Descriptor()
}

func (ListProcessesMatchType) Type() protoreflect.EnumType {
	return &file_remote_proto_enumTypes[0]
}

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

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

type RemoteMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to MessageType:
	//
	//	*RemoteMessage_MessageBatch
	//	*RemoteMessage_ConnectRequest
	//	*RemoteMessage_ConnectResponse
	//	*RemoteMessage_DisconnectRequest
	MessageType   isRemoteMessage_MessageType `protobuf_oneof:"message_type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RemoteMessage) ProtoMessage() {}

func (x *RemoteMessage) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 RemoteMessage.ProtoReflect.Descriptor instead.
func (*RemoteMessage) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{0}
}

func (x *RemoteMessage) GetMessageType() isRemoteMessage_MessageType {
	if x != nil {
		return x.MessageType
	}
	return nil
}

func (x *RemoteMessage) GetMessageBatch() *MessageBatch {
	if x != nil {
		if x, ok := x.MessageType.(*RemoteMessage_MessageBatch); ok {
			return x.MessageBatch
		}
	}
	return nil
}

func (x *RemoteMessage) GetConnectRequest() *ConnectRequest {
	if x != nil {
		if x, ok := x.MessageType.(*RemoteMessage_ConnectRequest); ok {
			return x.ConnectRequest
		}
	}
	return nil
}

func (x *RemoteMessage) GetConnectResponse() *ConnectResponse {
	if x != nil {
		if x, ok := x.MessageType.(*RemoteMessage_ConnectResponse); ok {
			return x.ConnectResponse
		}
	}
	return nil
}

func (x *RemoteMessage) GetDisconnectRequest() *DisconnectRequest {
	if x != nil {
		if x, ok := x.MessageType.(*RemoteMessage_DisconnectRequest); ok {
			return x.DisconnectRequest
		}
	}
	return nil
}

type isRemoteMessage_MessageType interface {
	isRemoteMessage_MessageType()
}

type RemoteMessage_MessageBatch struct {
	MessageBatch *MessageBatch `protobuf:"bytes,1,opt,name=message_batch,json=messageBatch,proto3,oneof"`
}

type RemoteMessage_ConnectRequest struct {
	ConnectRequest *ConnectRequest `protobuf:"bytes,2,opt,name=connect_request,json=connectRequest,proto3,oneof"`
}

type RemoteMessage_ConnectResponse struct {
	ConnectResponse *ConnectResponse `protobuf:"bytes,3,opt,name=connect_response,json=connectResponse,proto3,oneof"`
}

type RemoteMessage_DisconnectRequest struct {
	DisconnectRequest *DisconnectRequest `protobuf:"bytes,4,opt,name=disconnect_request,json=disconnectRequest,proto3,oneof"`
}

func (*RemoteMessage_MessageBatch) isRemoteMessage_MessageType() {}

func (*RemoteMessage_ConnectRequest) isRemoteMessage_MessageType() {}

func (*RemoteMessage_ConnectResponse) isRemoteMessage_MessageType() {}

func (*RemoteMessage_DisconnectRequest) isRemoteMessage_MessageType() {}

type MessageBatch struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TypeNames     []string               `protobuf:"bytes,1,rep,name=type_names,json=typeNames,proto3" json:"type_names,omitempty"`
	Targets       []string               `protobuf:"bytes,2,rep,name=targets,proto3" json:"targets,omitempty"`
	Envelopes     []*MessageEnvelope     `protobuf:"bytes,3,rep,name=envelopes,proto3" json:"envelopes,omitempty"`
	Senders       []*actor.PID           `protobuf:"bytes,4,rep,name=senders,proto3" json:"senders,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageBatch) ProtoMessage() {}

func (x *MessageBatch) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 MessageBatch.ProtoReflect.Descriptor instead.
func (*MessageBatch) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{1}
}

func (x *MessageBatch) GetTypeNames() []string {
	if x != nil {
		return x.TypeNames
	}
	return nil
}

func (x *MessageBatch) GetTargets() []string {
	if x != nil {
		return x.Targets
	}
	return nil
}

func (x *MessageBatch) GetEnvelopes() []*MessageEnvelope {
	if x != nil {
		return x.Envelopes
	}
	return nil
}

func (x *MessageBatch) GetSenders() []*actor.PID {
	if x != nil {
		return x.Senders
	}
	return nil
}

type MessageEnvelope struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	TypeId          int32                  `protobuf:"varint,1,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"`
	MessageData     []byte                 `protobuf:"bytes,2,opt,name=message_data,json=messageData,proto3" json:"message_data,omitempty"`
	Target          int32                  `protobuf:"varint,3,opt,name=target,proto3" json:"target,omitempty"`
	Sender          int32                  `protobuf:"varint,4,opt,name=sender,proto3" json:"sender,omitempty"`
	SerializerId    int32                  `protobuf:"varint,5,opt,name=serializer_id,json=serializerId,proto3" json:"serializer_id,omitempty"`
	MessageHeader   *MessageHeader         `protobuf:"bytes,6,opt,name=message_header,json=messageHeader,proto3" json:"message_header,omitempty"`
	TargetRequestId uint32                 `protobuf:"varint,7,opt,name=target_request_id,json=targetRequestId,proto3" json:"target_request_id,omitempty"`
	SenderRequestId uint32                 `protobuf:"varint,8,opt,name=sender_request_id,json=senderRequestId,proto3" json:"sender_request_id,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*MessageEnvelope) ProtoMessage() {}

func (x *MessageEnvelope) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 MessageEnvelope.ProtoReflect.Descriptor instead.
func (*MessageEnvelope) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{2}
}

func (x *MessageEnvelope) GetTypeId() int32 {
	if x != nil {
		return x.TypeId
	}
	return 0
}

func (x *MessageEnvelope) GetMessageData() []byte {
	if x != nil {
		return x.MessageData
	}
	return nil
}

func (x *MessageEnvelope) GetTarget() int32 {
	if x != nil {
		return x.Target
	}
	return 0
}

func (x *MessageEnvelope) GetSender() int32 {
	if x != nil {
		return x.Sender
	}
	return 0
}

func (x *MessageEnvelope) GetSerializerId() int32 {
	if x != nil {
		return x.SerializerId
	}
	return 0
}

func (x *MessageEnvelope) GetMessageHeader() *MessageHeader {
	if x != nil {
		return x.MessageHeader
	}
	return nil
}

func (x *MessageEnvelope) GetTargetRequestId() uint32 {
	if x != nil {
		return x.TargetRequestId
	}
	return 0
}

func (x *MessageEnvelope) GetSenderRequestId() uint32 {
	if x != nil {
		return x.SenderRequestId
	}
	return 0
}

type MessageHeader struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	HeaderData    map[string]string      `protobuf:"bytes,1,rep,name=header_data,json=headerData,proto3" json:"header_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageHeader) ProtoMessage() {}

func (x *MessageHeader) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 MessageHeader.ProtoReflect.Descriptor instead.
func (*MessageHeader) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{3}
}

func (x *MessageHeader) GetHeaderData() map[string]string {
	if x != nil {
		return x.HeaderData
	}
	return nil
}

type ActorPidRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Kind          string                 `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ActorPidRequest) ProtoMessage() {}

func (x *ActorPidRequest) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ActorPidRequest.ProtoReflect.Descriptor instead.
func (*ActorPidRequest) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{4}
}

func (x *ActorPidRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *ActorPidRequest) GetKind() string {
	if x != nil {
		return x.Kind
	}
	return ""
}

type ActorPidResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           *actor.PID             `protobuf:"bytes,1,opt,name=pid,proto3" json:"pid,omitempty"`
	StatusCode    int32                  `protobuf:"varint,2,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ActorPidResponse) ProtoMessage() {}

func (x *ActorPidResponse) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ActorPidResponse.ProtoReflect.Descriptor instead.
func (*ActorPidResponse) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{5}
}

func (x *ActorPidResponse) GetPid() *actor.PID {
	if x != nil {
		return x.Pid
	}
	return nil
}

func (x *ActorPidResponse) GetStatusCode() int32 {
	if x != nil {
		return x.StatusCode
	}
	return 0
}

type ConnectRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to ConnectionType:
	//
	//	*ConnectRequest_ClientConnection
	//	*ConnectRequest_ServerConnection
	ConnectionType isConnectRequest_ConnectionType `protobuf_oneof:"connection_type"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*ConnectRequest) ProtoMessage() {}

func (x *ConnectRequest) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ConnectRequest.ProtoReflect.Descriptor instead.
func (*ConnectRequest) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{6}
}

func (x *ConnectRequest) GetConnectionType() isConnectRequest_ConnectionType {
	if x != nil {
		return x.ConnectionType
	}
	return nil
}

func (x *ConnectRequest) GetClientConnection() *ClientConnection {
	if x != nil {
		if x, ok := x.ConnectionType.(*ConnectRequest_ClientConnection); ok {
			return x.ClientConnection
		}
	}
	return nil
}

func (x *ConnectRequest) GetServerConnection() *ServerConnection {
	if x != nil {
		if x, ok := x.ConnectionType.(*ConnectRequest_ServerConnection); ok {
			return x.ServerConnection
		}
	}
	return nil
}

type isConnectRequest_ConnectionType interface {
	isConnectRequest_ConnectionType()
}

type ConnectRequest_ClientConnection struct {
	ClientConnection *ClientConnection `protobuf:"bytes,1,opt,name=client_connection,json=clientConnection,proto3,oneof"`
}

type ConnectRequest_ServerConnection struct {
	ServerConnection *ServerConnection `protobuf:"bytes,2,opt,name=server_connection,json=serverConnection,proto3,oneof"`
}

func (*ConnectRequest_ClientConnection) isConnectRequest_ConnectionType() {}

func (*ConnectRequest_ServerConnection) isConnectRequest_ConnectionType() {}

type ConnectResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	MemberId      string                 `protobuf:"bytes,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
	Blocked       bool                   `protobuf:"varint,3,opt,name=blocked,proto3" json:"blocked,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConnectResponse) ProtoMessage() {}

func (x *ConnectResponse) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ConnectResponse.ProtoReflect.Descriptor instead.
func (*ConnectResponse) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{7}
}

func (x *ConnectResponse) GetMemberId() string {
	if x != nil {
		return x.MemberId
	}
	return ""
}

func (x *ConnectResponse) GetBlocked() bool {
	if x != nil {
		return x.Blocked
	}
	return false
}

type DisconnectRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DisconnectRequest) ProtoMessage() {}

func (x *DisconnectRequest) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 DisconnectRequest.ProtoReflect.Descriptor instead.
func (*DisconnectRequest) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{8}
}

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

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

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

func (*ClientConnection) ProtoMessage() {}

func (x *ClientConnection) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ClientConnection.ProtoReflect.Descriptor instead.
func (*ClientConnection) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{9}
}

func (x *ClientConnection) GetMemberId() string {
	if x != nil {
		return x.MemberId
	}
	return ""
}

type ServerConnection struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	MemberId      string                 `protobuf:"bytes,1,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
	Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	BlockList     []string               `protobuf:"bytes,3,rep,name=block_list,json=blockList,proto3" json:"block_list,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerConnection) ProtoMessage() {}

func (x *ServerConnection) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ServerConnection.ProtoReflect.Descriptor instead.
func (*ServerConnection) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{10}
}

func (x *ServerConnection) GetMemberId() string {
	if x != nil {
		return x.MemberId
	}
	return ""
}

func (x *ServerConnection) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

func (x *ServerConnection) GetBlockList() []string {
	if x != nil {
		return x.BlockList
	}
	return nil
}

type ListProcessesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pattern       string                 `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	Type          ListProcessesMatchType `protobuf:"varint,2,opt,name=type,proto3,enum=remote.ListProcessesMatchType" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListProcessesRequest) ProtoMessage() {}

func (x *ListProcessesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_remote_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 ListProcessesRequest.ProtoReflect.Descriptor instead.
func (*ListProcessesRequest) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{11}
}

func (x *ListProcessesRequest) GetPattern() string {
	if x != nil {
		return x.Pattern
	}
	return ""
}

func (x *ListProcessesRequest) GetType() ListProcessesMatchType {
	if x != nil {
		return x.Type
	}
	return ListProcessesMatchType_MatchPartOfString
}

type ListProcessesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pids          []*actor.PID           `protobuf:"bytes,1,rep,name=pids,proto3" json:"pids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListProcessesResponse) Reset() {
	*x = ListProcessesResponse{}
	mi := &file_remote_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListProcessesResponse) ProtoMessage() {}

func (x *ListProcessesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_remote_proto_msgTypes[12]
	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 ListProcessesResponse.ProtoReflect.Descriptor instead.
func (*ListProcessesResponse) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{12}
}

func (x *ListProcessesResponse) GetPids() []*actor.PID {
	if x != nil {
		return x.Pids
	}
	return nil
}

type GetProcessDiagnosticsRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           *actor.PID             `protobuf:"bytes,1,opt,name=pid,proto3" json:"pid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetProcessDiagnosticsRequest) Reset() {
	*x = GetProcessDiagnosticsRequest{}
	mi := &file_remote_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetProcessDiagnosticsRequest) ProtoMessage() {}

func (x *GetProcessDiagnosticsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_remote_proto_msgTypes[13]
	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 GetProcessDiagnosticsRequest.ProtoReflect.Descriptor instead.
func (*GetProcessDiagnosticsRequest) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{13}
}

func (x *GetProcessDiagnosticsRequest) GetPid() *actor.PID {
	if x != nil {
		return x.Pid
	}
	return nil
}

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

func (x *GetProcessDiagnosticsResponse) Reset() {
	*x = GetProcessDiagnosticsResponse{}
	mi := &file_remote_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetProcessDiagnosticsResponse) ProtoMessage() {}

func (x *GetProcessDiagnosticsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_remote_proto_msgTypes[14]
	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 GetProcessDiagnosticsResponse.ProtoReflect.Descriptor instead.
func (*GetProcessDiagnosticsResponse) Descriptor() ([]byte, []int) {
	return file_remote_proto_rawDescGZIP(), []int{14}
}

func (x *GetProcessDiagnosticsResponse) GetDiagnosticsString() string {
	if x != nil {
		return x.DiagnosticsString
	}
	return ""
}

var File_remote_proto protoreflect.FileDescriptor

const file_remote_proto_rawDesc = "" +
	"\n" +
	"\fremote.proto\x12\x06remote\x1a\vactor.proto\"\xb1\x02\n" +
	"\rRemoteMessage\x12;\n" +
	"\rmessage_batch\x18\x01 \x01(\v2\x14.remote.MessageBatchH\x00R\fmessageBatch\x12A\n" +
	"\x0fconnect_request\x18\x02 \x01(\v2\x16.remote.ConnectRequestH\x00R\x0econnectRequest\x12D\n" +
	"\x10connect_response\x18\x03 \x01(\v2\x17.remote.ConnectResponseH\x00R\x0fconnectResponse\x12J\n" +
	"\x12disconnect_request\x18\x04 \x01(\v2\x19.remote.DisconnectRequestH\x00R\x11disconnectRequestB\x0e\n" +
	"\fmessage_type\"\xa4\x01\n" +
	"\fMessageBatch\x12\x1d\n" +
	"\n" +
	"type_names\x18\x01 \x03(\tR\ttypeNames\x12\x18\n" +
	"\atargets\x18\x02 \x03(\tR\atargets\x125\n" +
	"\tenvelopes\x18\x03 \x03(\v2\x17.remote.MessageEnvelopeR\tenvelopes\x12$\n" +
	"\asenders\x18\x04 \x03(\v2\n" +
	".actor.PIDR\asenders\"\xb8\x02\n" +
	"\x0fMessageEnvelope\x12\x17\n" +
	"\atype_id\x18\x01 \x01(\x05R\x06typeId\x12!\n" +
	"\fmessage_data\x18\x02 \x01(\fR\vmessageData\x12\x16\n" +
	"\x06target\x18\x03 \x01(\x05R\x06target\x12\x16\n" +
	"\x06sender\x18\x04 \x01(\x05R\x06sender\x12#\n" +
	"\rserializer_id\x18\x05 \x01(\x05R\fserializerId\x12<\n" +
	"\x0emessage_header\x18\x06 \x01(\v2\x15.remote.MessageHeaderR\rmessageHeader\x12*\n" +
	"\x11target_request_id\x18\a \x01(\rR\x0ftargetRequestId\x12*\n" +
	"\x11sender_request_id\x18\b \x01(\rR\x0fsenderRequestId\"\x96\x01\n" +
	"\rMessageHeader\x12F\n" +
	"\vheader_data\x18\x01 \x03(\v2%.remote.MessageHeader.HeaderDataEntryR\n" +
	"headerData\x1a=\n" +
	"\x0fHeaderDataEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"9\n" +
	"\x0fActorPidRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" +
	"\x04kind\x18\x02 \x01(\tR\x04kind\"Q\n" +
	"\x10ActorPidResponse\x12\x1c\n" +
	"\x03pid\x18\x01 \x01(\v2\n" +
	".actor.PIDR\x03pid\x12\x1f\n" +
	"\vstatus_code\x18\x02 \x01(\x05R\n" +
	"statusCode\"\xb5\x01\n" +
	"\x0eConnectRequest\x12G\n" +
	"\x11client_connection\x18\x01 \x01(\v2\x18.remote.ClientConnectionH\x00R\x10clientConnection\x12G\n" +
	"\x11server_connection\x18\x02 \x01(\v2\x18.remote.ServerConnectionH\x00R\x10serverConnectionB\x11\n" +
	"\x0fconnection_type\"H\n" +
	"\x0fConnectResponse\x12\x1b\n" +
	"\tmember_id\x18\x02 \x01(\tR\bmemberId\x12\x18\n" +
	"\ablocked\x18\x03 \x01(\bR\ablocked\"\x13\n" +
	"\x11DisconnectRequest\"/\n" +
	"\x10ClientConnection\x12\x1b\n" +
	"\tmember_id\x18\x01 \x01(\tR\bmemberId\"h\n" +
	"\x10ServerConnection\x12\x1b\n" +
	"\tmember_id\x18\x01 \x01(\tR\bmemberId\x12\x18\n" +
	"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x1d\n" +
	"\n" +
	"block_list\x18\x03 \x03(\tR\tblockList\"d\n" +
	"\x14ListProcessesRequest\x12\x18\n" +
	"\apattern\x18\x01 \x01(\tR\apattern\x122\n" +
	"\x04type\x18\x02 \x01(\x0e2\x1e.remote.ListProcessesMatchTypeR\x04type\"7\n" +
	"\x15ListProcessesResponse\x12\x1e\n" +
	"\x04pids\x18\x01 \x03(\v2\n" +
	".actor.PIDR\x04pids\"<\n" +
	"\x1cGetProcessDiagnosticsRequest\x12\x1c\n" +
	"\x03pid\x18\x01 \x01(\v2\n" +
	".actor.PIDR\x03pid\"N\n" +
	"\x1dGetProcessDiagnosticsResponse\x12-\n" +
	"\x12diagnostics_string\x18\x01 \x01(\tR\x11diagnosticsString*U\n" +
	"\x16ListProcessesMatchType\x12\x15\n" +
	"\x11MatchPartOfString\x10\x00\x12\x14\n" +
	"\x10MatchExactString\x10\x01\x12\x0e\n" +
	"\n" +
	"MatchRegex\x10\x022\x81\x02\n" +
	"\bRemoting\x12=\n" +
	"\aReceive\x12\x15.remote.RemoteMessage\x1a\x15.remote.RemoteMessage\"\x00(\x010\x01\x12N\n" +
	"\rListProcesses\x12\x1c.remote.ListProcessesRequest\x1a\x1d.remote.ListProcessesResponse\"\x00\x12f\n" +
	"\x15GetProcessDiagnostics\x12$.remote.GetProcessDiagnosticsRequest\x1a%.remote.GetProcessDiagnosticsResponse\"\x00B+Z)/github.com/asynkron/protoactor-go/remoteb\x06proto3"

var (
	file_remote_proto_rawDescOnce sync.Once
	file_remote_proto_rawDescData []byte
)

func file_remote_proto_rawDescGZIP() []byte {
	file_remote_proto_rawDescOnce.Do(func() {
		file_remote_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_remote_proto_rawDesc), len(file_remote_proto_rawDesc)))
	})
	return file_remote_proto_rawDescData
}

var file_remote_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_remote_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
var file_remote_proto_goTypes = []any{
	(ListProcessesMatchType)(0),           // 0: remote.ListProcessesMatchType
	(*RemoteMessage)(nil),                 // 1: remote.RemoteMessage
	(*MessageBatch)(nil),                  // 2: remote.MessageBatch
	(*MessageEnvelope)(nil),               // 3: remote.MessageEnvelope
	(*MessageHeader)(nil),                 // 4: remote.MessageHeader
	(*ActorPidRequest)(nil),               // 5: remote.ActorPidRequest
	(*ActorPidResponse)(nil),              // 6: remote.ActorPidResponse
	(*ConnectRequest)(nil),                // 7: remote.ConnectRequest
	(*ConnectResponse)(nil),               // 8: remote.ConnectResponse
	(*DisconnectRequest)(nil),             // 9: remote.DisconnectRequest
	(*ClientConnection)(nil),              // 10: remote.ClientConnection
	(*ServerConnection)(nil),              // 11: remote.ServerConnection
	(*ListProcessesRequest)(nil),          // 12: remote.ListProcessesRequest
	(*ListProcessesResponse)(nil),         // 13: remote.ListProcessesResponse
	(*GetProcessDiagnosticsRequest)(nil),  // 14: remote.GetProcessDiagnosticsRequest
	(*GetProcessDiagnosticsResponse)(nil), // 15: remote.GetProcessDiagnosticsResponse
	nil,                                   // 16: remote.MessageHeader.HeaderDataEntry
	(*actor.PID)(nil),                     // 17: actor.PID
}
var file_remote_proto_depIdxs = []int32{
	2,  // 0: remote.RemoteMessage.message_batch:type_name -> remote.MessageBatch
	7,  // 1: remote.RemoteMessage.connect_request:type_name -> remote.ConnectRequest
	8,  // 2: remote.RemoteMessage.connect_response:type_name -> remote.ConnectResponse
	9,  // 3: remote.RemoteMessage.disconnect_request:type_name -> remote.DisconnectRequest
	3,  // 4: remote.MessageBatch.envelopes:type_name -> remote.MessageEnvelope
	17, // 5: remote.MessageBatch.senders:type_name -> actor.PID
	4,  // 6: remote.MessageEnvelope.message_header:type_name -> remote.MessageHeader
	16, // 7: remote.MessageHeader.header_data:type_name -> remote.MessageHeader.HeaderDataEntry
	17, // 8: remote.ActorPidResponse.pid:type_name -> actor.PID
	10, // 9: remote.ConnectRequest.client_connection:type_name -> remote.ClientConnection
	11, // 10: remote.ConnectRequest.server_connection:type_name -> remote.ServerConnection
	0,  // 11: remote.ListProcessesRequest.type:type_name -> remote.ListProcessesMatchType
	17, // 12: remote.ListProcessesResponse.pids:type_name -> actor.PID
	17, // 13: remote.GetProcessDiagnosticsRequest.pid:type_name -> actor.PID
	1,  // 14: remote.Remoting.Receive:input_type -> remote.RemoteMessage
	12, // 15: remote.Remoting.ListProcesses:input_type -> remote.ListProcessesRequest
	14, // 16: remote.Remoting.GetProcessDiagnostics:input_type -> remote.GetProcessDiagnosticsRequest
	1,  // 17: remote.Remoting.Receive:output_type -> remote.RemoteMessage
	13, // 18: remote.Remoting.ListProcesses:output_type -> remote.ListProcessesResponse
	15, // 19: remote.Remoting.GetProcessDiagnostics:output_type -> remote.GetProcessDiagnosticsResponse
	17, // [17:20] is the sub-list for method output_type
	14, // [14:17] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_remote_proto_init() }
func file_remote_proto_init() {
	if File_remote_proto != nil {
		return
	}
	file_remote_proto_msgTypes[0].OneofWrappers = []any{
		(*RemoteMessage_MessageBatch)(nil),
		(*RemoteMessage_ConnectRequest)(nil),
		(*RemoteMessage_ConnectResponse)(nil),
		(*RemoteMessage_DisconnectRequest)(nil),
	}
	file_remote_proto_msgTypes[6].OneofWrappers = []any{
		(*ConnectRequest_ClientConnection)(nil),
		(*ConnectRequest_ServerConnection)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_remote_proto_rawDesc), len(file_remote_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   16,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_remote_proto_goTypes,
		DependencyIndexes: file_remote_proto_depIdxs,
		EnumInfos:         file_remote_proto_enumTypes,
		MessageInfos:      file_remote_proto_msgTypes,
	}.Build()
	File_remote_proto = out.File
	file_remote_proto_goTypes = nil
	file_remote_proto_depIdxs = nil
}
