entity

type ActionCommand struct {

	// The name of the service this action is on.
	ServiceName string `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// Command name
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// The command payload.
	Payload *any.Any `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	// Metadata
	Metadata *protocol.Metadata `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type ActionProtocolClient interface {
	// Handle a unary command.
	//
	// The input command will contain the service name, command name, request metadata and the command
	// payload. The reply may contain a direct reply, a forward or a failure, and it may contain many
	// side effects.
	HandleUnary(ctx context.Context, in *ActionCommand, opts ...grpc.CallOption) (*ActionResponse, error)
	// Handle a streamed in command.
	//
	// The first message in will contain the request metadata, including the service name and command
	// name. It will not have an associated payload set. This will be followed by zero to many messages
	// in with a payload, but no service name or command name set.
	//
	// If the underlying transport supports per stream metadata, rather than per message metadata, then
	// that metadata will only be included in the metadata of the first message. In contrast, if the
	// underlying transport supports per message metadata, there will be no metadata on the first message,
	// the metadata will instead be found on each subsequent message.
	//
	// The semantics of stream closure in this protocol map 1:1 with the semantics of gRPC stream closure,
	// that is, when the client closes the stream, the stream is considered half closed, and the server
	// should eventually, but not necessarily immediately, send a response message with a status code and
	// trailers.
	//
	// If however the server sends a response message before the client closes the stream, the stream is
	// completely closed, and the client should handle this and stop sending more messages.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamedIn(ctx context.Context, opts ...grpc.CallOption) (ActionProtocol_HandleStreamedInClient, error)
	// Handle a streamed out command.
	//
	// The input command will contain the service name, command name, request metadata and the command
	// payload. Zero or more replies may be sent, each containing either a direct reply, a forward or a
	// failure, and each may contain many side effects. The stream to the client will be closed when the
	// this stream is closed, with the same status as this stream is closed with.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamedOut(ctx context.Context, in *ActionCommand, opts ...grpc.CallOption) (ActionProtocol_HandleStreamedOutClient, error)
	// Handle a full duplex streamed command.
	//
	// The first message in will contain the request metadata, including the service name and command
	// name. It will not have an associated payload set. This will be followed by zero to many messages
	// in with a payload, but no service name or command name set.
	//
	// Zero or more replies may be sent, each containing either a direct reply, a forward or a failure,
	// and each may contain many side effects.
	//
	// If the underlying transport supports per stream metadata, rather than per message metadata, then
	// that metadata will only be included in the metadata of the first message. In contrast, if the
	// underlying transport supports per message metadata, there will be no metadata on the first message,
	// the metadata will instead be found on each subsequent message.
	//
	// The semantics of stream closure in this protocol map 1:1 with the semantics of gRPC stream closure,
	// that is, when the client closes the stream, the stream is considered half closed, and the server
	// should eventually, but not necessarily immediately, close the stream with a status code and
	// trailers.
	//
	// If however the server closes the stream with a status code and trailers, the stream is immediately
	// considered completely closed, and no further messages sent by the client will be handled by the
	// server.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamed(ctx context.Context, opts ...grpc.CallOption) (ActionProtocol_HandleStreamedClient, error)
}

type ActionProtocolServer interface {
	// Handle a unary command.
	//
	// The input command will contain the service name, command name, request metadata and the command
	// payload. The reply may contain a direct reply, a forward or a failure, and it may contain many
	// side effects.
	HandleUnary(context.Context, *ActionCommand) (*ActionResponse, error)
	// Handle a streamed in command.
	//
	// The first message in will contain the request metadata, including the service name and command
	// name. It will not have an associated payload set. This will be followed by zero to many messages
	// in with a payload, but no service name or command name set.
	//
	// If the underlying transport supports per stream metadata, rather than per message metadata, then
	// that metadata will only be included in the metadata of the first message. In contrast, if the
	// underlying transport supports per message metadata, there will be no metadata on the first message,
	// the metadata will instead be found on each subsequent message.
	//
	// The semantics of stream closure in this protocol map 1:1 with the semantics of gRPC stream closure,
	// that is, when the client closes the stream, the stream is considered half closed, and the server
	// should eventually, but not necessarily immediately, send a response message with a status code and
	// trailers.
	//
	// If however the server sends a response message before the client closes the stream, the stream is
	// completely closed, and the client should handle this and stop sending more messages.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamedIn(ActionProtocol_HandleStreamedInServer) error
	// Handle a streamed out command.
	//
	// The input command will contain the service name, command name, request metadata and the command
	// payload. Zero or more replies may be sent, each containing either a direct reply, a forward or a
	// failure, and each may contain many side effects. The stream to the client will be closed when the
	// this stream is closed, with the same status as this stream is closed with.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamedOut(*ActionCommand, ActionProtocol_HandleStreamedOutServer) error
	// Handle a full duplex streamed command.
	//
	// The first message in will contain the request metadata, including the service name and command
	// name. It will not have an associated payload set. This will be followed by zero to many messages
	// in with a payload, but no service name or command name set.
	//
	// Zero or more replies may be sent, each containing either a direct reply, a forward or a failure,
	// and each may contain many side effects.
	//
	// If the underlying transport supports per stream metadata, rather than per message metadata, then
	// that metadata will only be included in the metadata of the first message. In contrast, if the
	// underlying transport supports per message metadata, there will be no metadata on the first message,
	// the metadata will instead be found on each subsequent message.
	//
	// The semantics of stream closure in this protocol map 1:1 with the semantics of gRPC stream closure,
	// that is, when the client closes the stream, the stream is considered half closed, and the server
	// should eventually, but not necessarily immediately, close the stream with a status code and
	// trailers.
	//
	// If however the server closes the stream with a status code and trailers, the stream is immediately
	// considered completely closed, and no further messages sent by the client will be handled by the
	// server.
	//
	// Either the client or the server may cancel the stream at any time, cancellation is indicated
	// through an HTTP2 stream RST message.
	HandleStreamed(ActionProtocol_HandleStreamedServer) error
	// contains filtered or unexported methods
}

type ActionProtocol_HandleStreamedClient interface {
	Send(*ActionCommand) error
	Recv() (*ActionResponse, error)
	grpc.ClientStream
}

type ActionProtocol_HandleStreamedInClient interface {
	Send(*ActionCommand) error
	CloseAndRecv() (*ActionResponse, error)
	grpc.ClientStream
}

type ActionProtocol_HandleStreamedInServer interface {
	SendAndClose(*ActionResponse) error
	Recv() (*ActionCommand, error)
	grpc.ServerStream
}

type ActionProtocol_HandleStreamedOutClient interface {
	Recv() (*ActionResponse, error)
	grpc.ClientStream
}

type ActionProtocol_HandleStreamedOutServer interface {
	Send(*ActionResponse) error
	grpc.ServerStream
}

type ActionProtocol_HandleStreamedServer interface {
	Send(*ActionResponse) error
	Recv() (*ActionCommand, error)
	grpc.ServerStream
}

type ActionResponse struct {

	// Types that are assignable to Response:
	//	*ActionResponse_Failure
	//	*ActionResponse_Reply
	//	*ActionResponse_Forward
	Response    isActionResponse_Response `protobuf_oneof:"response"`
	SideEffects []*protocol.SideEffect    `protobuf:"bytes,4,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	// contains filtered or unexported fields
}

type ActionResponse_Failure struct {
	Failure *protocol.Failure `protobuf:"bytes,1,opt,name=failure,proto3,oneof"`
}

type ActionResponse_Forward struct {
	Forward *protocol.Forward `protobuf:"bytes,3,opt,name=forward,proto3,oneof"`
}

type ActionResponse_Reply struct {
	Reply *protocol.Reply `protobuf:"bytes,2,opt,name=reply,proto3,oneof"`
}

type CrdtClient interface {
	// After invoking handle, the first message sent will always be a CrdtInit message, containing the entity ID, and,
	// if it exists or is available, a delta for the inital state of the entity. After that, one or more commands may
	// be sent, as well as deltas as they arrive.
	//
	// The user function must respond with one reply per command in. They do not necessarily have to be sent in the same
	// order that the commands were sent, the command ID is used to correlate commands to replies.
	Handle(ctx context.Context, opts ...grpc.CallOption) (Crdt_HandleClient, error)
}

type CrdtClock int32

type CrdtDelete struct {
	// contains filtered or unexported fields
}

type CrdtDelta struct {

	// Types that are assignable to Delta:
	//	*CrdtDelta_Gcounter
	//	*CrdtDelta_Pncounter
	//	*CrdtDelta_Gset
	//	*CrdtDelta_Orset
	//	*CrdtDelta_Lwwregister
	//	*CrdtDelta_Flag
	//	*CrdtDelta_Ormap
	//	*CrdtDelta_Vote
	Delta isCrdtDelta_Delta `protobuf_oneof:"delta"`
	// contains filtered or unexported fields
}

type CrdtDelta_Flag struct {
	Flag *FlagDelta `protobuf:"bytes,6,opt,name=flag,proto3,oneof"`
}

type CrdtDelta_Gcounter struct {
	Gcounter *GCounterDelta `protobuf:"bytes,1,opt,name=gcounter,proto3,oneof"`
}

type CrdtDelta_Gset struct {
	Gset *GSetDelta `protobuf:"bytes,3,opt,name=gset,proto3,oneof"`
}

type CrdtDelta_Lwwregister struct {
	Lwwregister *LWWRegisterDelta `protobuf:"bytes,5,opt,name=lwwregister,proto3,oneof"`
}

type CrdtDelta_Ormap struct {
	Ormap *ORMapDelta `protobuf:"bytes,7,opt,name=ormap,proto3,oneof"`
}

type CrdtDelta_Orset struct {
	Orset *ORSetDelta `protobuf:"bytes,4,opt,name=orset,proto3,oneof"`
}

type CrdtDelta_Pncounter struct {
	Pncounter *PNCounterDelta `protobuf:"bytes,2,opt,name=pncounter,proto3,oneof"`
}

type CrdtDelta_Vote struct {
	Vote *VoteDelta `protobuf:"bytes,8,opt,name=vote,proto3,oneof"`
}

type CrdtInit struct {
	ServiceName string     `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	EntityId    string     `protobuf:"bytes,2,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	Delta       *CrdtDelta `protobuf:"bytes,3,opt,name=delta,proto3" json:"delta,omitempty"`
	// contains filtered or unexported fields
}

type CrdtReply struct {
	CommandId    int64                  `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	ClientAction *protocol.ClientAction `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	SideEffects  []*protocol.SideEffect `protobuf:"bytes,4,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	StateAction  *CrdtStateAction       `protobuf:"bytes,5,opt,name=state_action,json=stateAction,proto3" json:"state_action,omitempty"`
	// If the request was streamed, setting this to true indicates that the command should
	// be handled as a stream. Subsequently, the user function may send CrdtStreamedMessage,
	// and a CrdtStreamCancelled message will be sent if the stream is cancelled (though
	// not if the a CrdtStreamedMessage ends the stream first).
	Streamed bool `protobuf:"varint,6,opt,name=streamed,proto3" json:"streamed,omitempty"`
	// contains filtered or unexported fields
}

type CrdtServer interface {
	// After invoking handle, the first message sent will always be a CrdtInit message, containing the entity ID, and,
	// if it exists or is available, a delta for the inital state of the entity. After that, one or more commands may
	// be sent, as well as deltas as they arrive.
	//
	// The user function must respond with one reply per command in. They do not necessarily have to be sent in the same
	// order that the commands were sent, the command ID is used to correlate commands to replies.
	Handle(Crdt_HandleServer) error
	// contains filtered or unexported methods
}

type CrdtStateAction struct {

	// Types that are assignable to Action:
	//	*CrdtStateAction_Update
	//	*CrdtStateAction_Delete
	Action           isCrdtStateAction_Action `protobuf_oneof:"action"`
	WriteConsistency CrdtWriteConsistency     `` /* 152-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CrdtStateAction_Delete struct {
	Delete *CrdtDelete `protobuf:"bytes,2,opt,name=delete,proto3,oneof"`
}

type CrdtStateAction_Update struct {
	Update *CrdtDelta `protobuf:"bytes,1,opt,name=update,proto3,oneof"`
}

type CrdtStreamCancelledResponse struct {
	CommandId   int64                  `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	SideEffects []*protocol.SideEffect `protobuf:"bytes,2,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	StateAction *CrdtStateAction       `protobuf:"bytes,3,opt,name=state_action,json=stateAction,proto3" json:"state_action,omitempty"`
	// contains filtered or unexported fields
}

type CrdtStreamIn struct {

	// Types that are assignable to Message:
	//	*CrdtStreamIn_Init
	//	*CrdtStreamIn_Delta
	//	*CrdtStreamIn_Delete
	//	*CrdtStreamIn_Command
	//	*CrdtStreamIn_StreamCancelled
	Message isCrdtStreamIn_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type CrdtStreamIn_Command struct {
	// A command, may be sent at any time.
	Command *protocol.Command `protobuf:"bytes,4,opt,name=command,proto3,oneof"`
}

type CrdtStreamIn_Delete struct {
	// Delete the entity. May be sent at any time. The user function should clear its state when it receives this.
	// A proxy may decide to terminate the stream after sending this.
	Delete *CrdtDelete `protobuf:"bytes,3,opt,name=delete,proto3,oneof"`
}

type CrdtStreamIn_Delta struct {
	// A delta to be applied to the current state. May be sent at any time.
	Delta *CrdtDelta `protobuf:"bytes,2,opt,name=delta,proto3,oneof"`
}

type CrdtStreamIn_Init struct {
	// Always sent first, and only once.
	Init *CrdtInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type CrdtStreamIn_StreamCancelled struct {
	// A stream has been cancelled.
	StreamCancelled *protocol.StreamCancelled `protobuf:"bytes,5,opt,name=stream_cancelled,json=streamCancelled,proto3,oneof"`
}

type CrdtStreamOut struct {

	// Types that are assignable to Message:
	//	*CrdtStreamOut_Reply
	//	*CrdtStreamOut_StreamedMessage
	//	*CrdtStreamOut_StreamCancelledResponse
	//	*CrdtStreamOut_Failure
	Message isCrdtStreamOut_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type CrdtStreamOut_Failure struct {
	// A failure. Either sent in response to a command, or sent if some other error occurs.
	Failure *protocol.Failure `protobuf:"bytes,4,opt,name=failure,proto3,oneof"`
}

type CrdtStreamOut_Reply struct {
	// A reply to an incoming command. Either one reply, or one failure, must be sent in response to each command.
	Reply *CrdtReply `protobuf:"bytes,1,opt,name=reply,proto3,oneof"`
}

type CrdtStreamOut_StreamCancelledResponse struct {
	// A stream cancelled response, may be sent in response to stream_cancelled.
	StreamCancelledResponse *CrdtStreamCancelledResponse `protobuf:"bytes,3,opt,name=stream_cancelled_response,json=streamCancelledResponse,proto3,oneof"`
}

type CrdtStreamOut_StreamedMessage struct {
	// A streamed message.
	StreamedMessage *CrdtStreamedMessage `protobuf:"bytes,2,opt,name=streamed_message,json=streamedMessage,proto3,oneof"`
}

type CrdtStreamedMessage struct {
	CommandId    int64                  `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	ClientAction *protocol.ClientAction `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	SideEffects  []*protocol.SideEffect `protobuf:"bytes,3,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	// Indicates the stream should end, no messages may be sent for this command after this.
	EndStream bool `protobuf:"varint,4,opt,name=end_stream,json=endStream,proto3" json:"end_stream,omitempty"`
	// contains filtered or unexported fields
}

type CrdtWriteConsistency int32

type Crdt_HandleClient interface {
	Send(*CrdtStreamIn) error
	Recv() (*CrdtStreamOut, error)
	grpc.ClientStream
}

type Crdt_HandleServer interface {
	Send(*CrdtStreamOut) error
	Recv() (*CrdtStreamIn, error)
	grpc.ServerStream
}

type EventSourcedClient interface {
	// The stream. One stream will be established per active entity.
	// Once established, the first message sent will be Init, which contains the entity ID, and,
	// if the entity has previously persisted a snapshot, it will contain that snapshot. It will
	// then send zero to many event messages, one for each event previously persisted. The entity
	// is expected to apply these to its state in a deterministic fashion. Once all the events
	// are sent, one to many commands are sent, with new commands being sent as new requests for
	// the entity come in. The entity is expected to reply to each command with exactly one reply
	// message. The entity should reply in order, and any events that the entity requests to be
	// persisted the entity should handle itself, applying them to its own state, as if they had
	// arrived as events when the event stream was being replayed on load.
	Handle(ctx context.Context, opts ...grpc.CallOption) (EventSourced_HandleClient, error)
}

type EventSourcedEvent struct {

	// The sequence number of the event.
	Sequence int64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// The event payload.
	Payload *any.Any `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	// contains filtered or unexported fields
}

type EventSourcedInit struct {
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// The ID of the entity.
	EntityId string `protobuf:"bytes,2,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	// If present the entity should initialise its state using this snapshot.
	Snapshot *EventSourcedSnapshot `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// contains filtered or unexported fields
}

type EventSourcedReply struct {

	// The id of the command being replied to. Must match the input command.
	CommandId int64 `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// The action to take
	ClientAction *protocol.ClientAction `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	// Any side effects to perform
	SideEffects []*protocol.SideEffect `protobuf:"bytes,3,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	// A list of events to persist - these will be persisted before the reply
	// is sent.
	Events []*any.Any `protobuf:"bytes,4,rep,name=events,proto3" json:"events,omitempty"`
	// An optional snapshot to persist. It is assumed that this snapshot will have
	// the state of any events in the events field applied to it. It is illegal to
	// send a snapshot without sending any events.
	Snapshot *any.Any `protobuf:"bytes,5,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// contains filtered or unexported fields
}

type EventSourcedServer interface {
	// The stream. One stream will be established per active entity.
	// Once established, the first message sent will be Init, which contains the entity ID, and,
	// if the entity has previously persisted a snapshot, it will contain that snapshot. It will
	// then send zero to many event messages, one for each event previously persisted. The entity
	// is expected to apply these to its state in a deterministic fashion. Once all the events
	// are sent, one to many commands are sent, with new commands being sent as new requests for
	// the entity come in. The entity is expected to reply to each command with exactly one reply
	// message. The entity should reply in order, and any events that the entity requests to be
	// persisted the entity should handle itself, applying them to its own state, as if they had
	// arrived as events when the event stream was being replayed on load.
	Handle(EventSourced_HandleServer) error
	// contains filtered or unexported methods
}

type EventSourcedSnapshot struct {

	// The sequence number when the snapshot was taken.
	SnapshotSequence int64 `protobuf:"varint,1,opt,name=snapshot_sequence,json=snapshotSequence,proto3" json:"snapshot_sequence,omitempty"`
	// The snapshot.
	Snapshot *any.Any `protobuf:"bytes,2,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// contains filtered or unexported fields
}

type EventSourcedStreamIn struct {

	// Types that are assignable to Message:
	//	*EventSourcedStreamIn_Init
	//	*EventSourcedStreamIn_Event
	//	*EventSourcedStreamIn_Command
	Message isEventSourcedStreamIn_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type EventSourcedStreamIn_Command struct {
	Command *protocol.Command `protobuf:"bytes,3,opt,name=command,proto3,oneof"`
}

type EventSourcedStreamIn_Event struct {
	Event *EventSourcedEvent `protobuf:"bytes,2,opt,name=event,proto3,oneof"`
}

type EventSourcedStreamIn_Init struct {
	Init *EventSourcedInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type EventSourcedStreamOut struct {

	// Types that are assignable to Message:
	//	*EventSourcedStreamOut_Reply
	//	*EventSourcedStreamOut_Failure
	Message isEventSourcedStreamOut_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type EventSourcedStreamOut_Failure struct {
	Failure *protocol.Failure `protobuf:"bytes,2,opt,name=failure,proto3,oneof"`
}

type EventSourcedStreamOut_Reply struct {
	Reply *EventSourcedReply `protobuf:"bytes,1,opt,name=reply,proto3,oneof"`
}

type EventSourced_HandleClient interface {
	Send(*EventSourcedStreamIn) error
	Recv() (*EventSourcedStreamOut, error)
	grpc.ClientStream
}

type EventSourced_HandleServer interface {
	Send(*EventSourcedStreamOut) error
	Recv() (*EventSourcedStreamIn, error)
	grpc.ServerStream
}

type FlagDelta struct {
	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type GCounterDelta struct {
	Increment uint64 `protobuf:"varint,1,opt,name=increment,proto3" json:"increment,omitempty"`
	// contains filtered or unexported fields
}

type GSetDelta struct {
	Added []*any.Any `protobuf:"bytes,1,rep,name=added,proto3" json:"added,omitempty"`
	// contains filtered or unexported fields
}

type LWWRegisterDelta struct {
	Value            *any.Any  `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Clock            CrdtClock `protobuf:"varint,2,opt,name=clock,proto3,enum=cloudstate.crdt.CrdtClock" json:"clock,omitempty"`
	CustomClockValue int64     `protobuf:"varint,3,opt,name=custom_clock_value,json=customClockValue,proto3" json:"custom_clock_value,omitempty"`
	// contains filtered or unexported fields
}

type ORMapDelta struct {
	Cleared bool               `protobuf:"varint,1,opt,name=cleared,proto3" json:"cleared,omitempty"`
	Removed []*any.Any         `protobuf:"bytes,2,rep,name=removed,proto3" json:"removed,omitempty"`
	Updated []*ORMapEntryDelta `protobuf:"bytes,3,rep,name=updated,proto3" json:"updated,omitempty"`
	Added   []*ORMapEntryDelta `protobuf:"bytes,4,rep,name=added,proto3" json:"added,omitempty"`
	// contains filtered or unexported fields
}

type ORMapEntryDelta struct {

	// The entry key.
	Key   *any.Any   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Delta *CrdtDelta `protobuf:"bytes,2,opt,name=delta,proto3" json:"delta,omitempty"`
	// contains filtered or unexported fields
}

type ORSetDelta struct {

	// If cleared is set, the set must be cleared before added is processed.
	Cleared bool       `protobuf:"varint,1,opt,name=cleared,proto3" json:"cleared,omitempty"`
	Removed []*any.Any `protobuf:"bytes,2,rep,name=removed,proto3" json:"removed,omitempty"`
	Added   []*any.Any `protobuf:"bytes,3,rep,name=added,proto3" json:"added,omitempty"`
	// contains filtered or unexported fields
}

type PNCounterDelta struct {
	Change int64 `protobuf:"zigzag64,1,opt,name=change,proto3" json:"change,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedActionProtocolServer struct {
}

type UnimplementedCrdtServer struct {
}

type UnimplementedEventSourcedServer struct {
}

type UnimplementedValueEntityServer struct {
}

type UnsafeActionProtocolServer interface {
	// contains filtered or unexported methods
}

type UnsafeCrdtServer interface {
	// contains filtered or unexported methods
}

type UnsafeEventSourcedServer interface {
	// contains filtered or unexported methods
}

type UnsafeValueEntityServer interface {
	// contains filtered or unexported methods
}

type ValueEntityAction struct {

	// Types that are assignable to Action:
	//	*ValueEntityAction_Update
	//	*ValueEntityAction_Delete
	Action isValueEntityAction_Action `protobuf_oneof:"action"`
	// contains filtered or unexported fields
}

type ValueEntityAction_Delete struct {
	Delete *ValueEntityDelete `protobuf:"bytes,2,opt,name=delete,proto3,oneof"`
}

type ValueEntityAction_Update struct {
	Update *ValueEntityUpdate `protobuf:"bytes,1,opt,name=update,proto3,oneof"`
}

type ValueEntityClient interface {
	// One stream will be established per active entity.
	// Once established, the first message sent will be Init, which contains the entity ID, and,
	// a state if the entity has previously persisted one. Once the Init message is sent, one to
	// many commands are sent to the entity. Each request coming in leads to a new command being sent
	// to the entity. The entity is expected to reply to each command with exactly one reply message.
	// The entity should process commands and reply to commands in the order they came
	// in. When processing a command the entity can read and persist (update or delete) the state.
	Handle(ctx context.Context, opts ...grpc.CallOption) (ValueEntity_HandleClient, error)
}

type ValueEntityDelete struct {
	// contains filtered or unexported fields
}

type ValueEntityInit struct {

	// The name of the service that implements this entity.
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// The id of the entity.
	EntityId string `protobuf:"bytes,2,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	// The initial state of the entity.
	State *ValueEntityInitState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	// contains filtered or unexported fields
}

type ValueEntityInitState struct {

	// The value of the entity state, if the entity has already been created.
	Value *any.Any `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type ValueEntityReply struct {

	// The command being replied to
	CommandId int64 `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// The action to take for the client response
	ClientAction *protocol.ClientAction `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	// Any side effects to perform
	SideEffects []*protocol.SideEffect `protobuf:"bytes,3,rep,name=side_effects,json=sideEffects,proto3" json:"side_effects,omitempty"`
	// The action to take on the value entity
	StateAction *ValueEntityAction `protobuf:"bytes,4,opt,name=state_action,json=stateAction,proto3" json:"state_action,omitempty"`
	// contains filtered or unexported fields
}

type ValueEntityServer interface {
	// One stream will be established per active entity.
	// Once established, the first message sent will be Init, which contains the entity ID, and,
	// a state if the entity has previously persisted one. Once the Init message is sent, one to
	// many commands are sent to the entity. Each request coming in leads to a new command being sent
	// to the entity. The entity is expected to reply to each command with exactly one reply message.
	// The entity should process commands and reply to commands in the order they came
	// in. When processing a command the entity can read and persist (update or delete) the state.
	Handle(ValueEntity_HandleServer) error
	// contains filtered or unexported methods
}

type ValueEntityStreamIn struct {

	// Types that are assignable to Message:
	//	*ValueEntityStreamIn_Init
	//	*ValueEntityStreamIn_Command
	Message isValueEntityStreamIn_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type ValueEntityStreamIn_Command struct {
	Command *protocol.Command `protobuf:"bytes,2,opt,name=command,proto3,oneof"`
}

type ValueEntityStreamIn_Init struct {
	Init *ValueEntityInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ValueEntityStreamOut struct {

	// Types that are assignable to Message:
	//	*ValueEntityStreamOut_Reply
	//	*ValueEntityStreamOut_Failure
	Message isValueEntityStreamOut_Message `protobuf_oneof:"message"`
	// contains filtered or unexported fields
}

type ValueEntityStreamOut_Failure struct {
	Failure *protocol.Failure `protobuf:"bytes,2,opt,name=failure,proto3,oneof"`
}

type ValueEntityStreamOut_Reply struct {
	Reply *ValueEntityReply `protobuf:"bytes,1,opt,name=reply,proto3,oneof"`
}

type ValueEntityUpdate struct {

	// The value to set.
	Value *any.Any `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type ValueEntity_HandleClient interface {
	Send(*ValueEntityStreamIn) error
	Recv() (*ValueEntityStreamOut, error)
	grpc.ClientStream
}

type ValueEntity_HandleServer interface {
	Send(*ValueEntityStreamOut) error
	Recv() (*ValueEntityStreamIn, error)
	grpc.ServerStream
}

type VoteDelta struct {

	// Set by the proxy initially or when the vote has changed.
	// Only set by the user function to change the node's current vote.
	SelfVote bool `protobuf:"varint,1,opt,name=self_vote,json=selfVote,proto3" json:"self_vote,omitempty"`
	// Only set by the proxy initially or when the vote has changed.
	// Ignored by the proxy when set by the user function.
	VotesFor int32 `protobuf:"varint,2,opt,name=votes_for,json=votesFor,proto3" json:"votes_for,omitempty"`
	// Only set by the proxy initially or when the vote has changed.
	// Ignored by the proxy when set by the user function.
	TotalVoters int32 `protobuf:"varint,3,opt,name=total_voters,json=totalVoters,proto3" json:"total_voters,omitempty"`
	// contains filtered or unexported fields
}