crdt.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: crdt.proto

package protocol

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type CrdtWriteConsistency int32

const (
	CrdtWriteConsistency_LOCAL    CrdtWriteConsistency = 0
	CrdtWriteConsistency_MAJORITY CrdtWriteConsistency = 1
	CrdtWriteConsistency_ALL      CrdtWriteConsistency = 2
)

var CrdtWriteConsistency_name = map[int32]string{
	0: "LOCAL",
	1: "MAJORITY",
	2: "ALL",
}

var CrdtWriteConsistency_value = map[string]int32{
	"LOCAL":    0,
	"MAJORITY": 1,
	"ALL":      2,
}

func (x CrdtWriteConsistency) String() string {
	return proto.EnumName(CrdtWriteConsistency_name, int32(x))
}

func (CrdtWriteConsistency) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{0}
}

type CrdtClock int32

const (
	// Use the default clock for deciding the last write, which is the system clocks
	// milliseconds since epoch.
	CrdtClock_DEFAULT CrdtClock = 0
	// Use the reverse semantics with the default clock, to enable first write wins.
	CrdtClock_REVERSE CrdtClock = 1
	// Use a custom clock value, set using custom_clock_value.
	CrdtClock_CUSTOM CrdtClock = 2
	// Use a custom clock value, but automatically increment it by one if the clock
	// value from the current value is equal to the custom_clock_value.
	CrdtClock_CUSTOM_AUTO_INCREMENT CrdtClock = 3
)

var CrdtClock_name = map[int32]string{
	0: "DEFAULT",
	1: "REVERSE",
	2: "CUSTOM",
	3: "CUSTOM_AUTO_INCREMENT",
}

var CrdtClock_value = map[string]int32{
	"DEFAULT":               0,
	"REVERSE":               1,
	"CUSTOM":                2,
	"CUSTOM_AUTO_INCREMENT": 3,
}

func (x CrdtClock) String() string {
	return proto.EnumName(CrdtClock_name, int32(x))
}

func (CrdtClock) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{1}
}

// Message for the Crdt handle stream in.
type CrdtStreamIn struct {
	// Types that are valid to be assigned to Message:
	//	*CrdtStreamIn_Init
	//	*CrdtStreamIn_State
	//	*CrdtStreamIn_Changed
	//	*CrdtStreamIn_Deleted
	//	*CrdtStreamIn_Command
	//	*CrdtStreamIn_StreamCancelled
	Message              isCrdtStreamIn_Message `protobuf_oneof:"message"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *CrdtStreamIn) Reset()         { *m = CrdtStreamIn{} }
func (m *CrdtStreamIn) String() string { return proto.CompactTextString(m) }
func (*CrdtStreamIn) ProtoMessage()    {}
func (*CrdtStreamIn) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{0}
}

func (m *CrdtStreamIn) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtStreamIn.Unmarshal(m, b)
}
func (m *CrdtStreamIn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtStreamIn.Marshal(b, m, deterministic)
}
func (m *CrdtStreamIn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtStreamIn.Merge(m, src)
}
func (m *CrdtStreamIn) XXX_Size() int {
	return xxx_messageInfo_CrdtStreamIn.Size(m)
}
func (m *CrdtStreamIn) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtStreamIn.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtStreamIn proto.InternalMessageInfo

type isCrdtStreamIn_Message interface {
	isCrdtStreamIn_Message()
}

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

type CrdtStreamIn_State struct {
	State *CrdtState `protobuf:"bytes,2,opt,name=state,proto3,oneof"`
}

type CrdtStreamIn_Changed struct {
	Changed *CrdtDelta `protobuf:"bytes,3,opt,name=changed,proto3,oneof"`
}

type CrdtStreamIn_Deleted struct {
	Deleted *CrdtDelete `protobuf:"bytes,4,opt,name=deleted,proto3,oneof"`
}

type CrdtStreamIn_Command struct {
	Command *Command `protobuf:"bytes,5,opt,name=command,proto3,oneof"`
}

type CrdtStreamIn_StreamCancelled struct {
	StreamCancelled *StreamCancelled `protobuf:"bytes,6,opt,name=stream_cancelled,json=streamCancelled,proto3,oneof"`
}

func (*CrdtStreamIn_Init) isCrdtStreamIn_Message() {}

func (*CrdtStreamIn_State) isCrdtStreamIn_Message() {}

func (*CrdtStreamIn_Changed) isCrdtStreamIn_Message() {}

func (*CrdtStreamIn_Deleted) isCrdtStreamIn_Message() {}

func (*CrdtStreamIn_Command) isCrdtStreamIn_Message() {}

func (*CrdtStreamIn_StreamCancelled) isCrdtStreamIn_Message() {}

func (m *CrdtStreamIn) GetMessage() isCrdtStreamIn_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *CrdtStreamIn) GetInit() *CrdtInit {
	if x, ok := m.GetMessage().(*CrdtStreamIn_Init); ok {
		return x.Init
	}
	return nil
}

func (m *CrdtStreamIn) GetState() *CrdtState {
	if x, ok := m.GetMessage().(*CrdtStreamIn_State); ok {
		return x.State
	}
	return nil
}

func (m *CrdtStreamIn) GetChanged() *CrdtDelta {
	if x, ok := m.GetMessage().(*CrdtStreamIn_Changed); ok {
		return x.Changed
	}
	return nil
}

func (m *CrdtStreamIn) GetDeleted() *CrdtDelete {
	if x, ok := m.GetMessage().(*CrdtStreamIn_Deleted); ok {
		return x.Deleted
	}
	return nil
}

func (m *CrdtStreamIn) GetCommand() *Command {
	if x, ok := m.GetMessage().(*CrdtStreamIn_Command); ok {
		return x.Command
	}
	return nil
}

func (m *CrdtStreamIn) GetStreamCancelled() *StreamCancelled {
	if x, ok := m.GetMessage().(*CrdtStreamIn_StreamCancelled); ok {
		return x.StreamCancelled
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrdtStreamIn) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrdtStreamIn_Init)(nil),
		(*CrdtStreamIn_State)(nil),
		(*CrdtStreamIn_Changed)(nil),
		(*CrdtStreamIn_Deleted)(nil),
		(*CrdtStreamIn_Command)(nil),
		(*CrdtStreamIn_StreamCancelled)(nil),
	}
}

// Message for the Crdt handle stream out.
type CrdtStreamOut struct {
	// Types that are valid to be assigned to Message:
	//	*CrdtStreamOut_Reply
	//	*CrdtStreamOut_StreamedMessage
	//	*CrdtStreamOut_StreamCancelledResponse
	//	*CrdtStreamOut_Failure
	Message              isCrdtStreamOut_Message `protobuf_oneof:"message"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *CrdtStreamOut) Reset()         { *m = CrdtStreamOut{} }
func (m *CrdtStreamOut) String() string { return proto.CompactTextString(m) }
func (*CrdtStreamOut) ProtoMessage()    {}
func (*CrdtStreamOut) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{1}
}

func (m *CrdtStreamOut) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtStreamOut.Unmarshal(m, b)
}
func (m *CrdtStreamOut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtStreamOut.Marshal(b, m, deterministic)
}
func (m *CrdtStreamOut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtStreamOut.Merge(m, src)
}
func (m *CrdtStreamOut) XXX_Size() int {
	return xxx_messageInfo_CrdtStreamOut.Size(m)
}
func (m *CrdtStreamOut) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtStreamOut.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtStreamOut proto.InternalMessageInfo

type isCrdtStreamOut_Message interface {
	isCrdtStreamOut_Message()
}

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

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

type CrdtStreamOut_StreamCancelledResponse struct {
	StreamCancelledResponse *CrdtStreamCancelledResponse `protobuf:"bytes,3,opt,name=stream_cancelled_response,json=streamCancelledResponse,proto3,oneof"`
}

type CrdtStreamOut_Failure struct {
	Failure *Failure `protobuf:"bytes,4,opt,name=failure,proto3,oneof"`
}

func (*CrdtStreamOut_Reply) isCrdtStreamOut_Message() {}

func (*CrdtStreamOut_StreamedMessage) isCrdtStreamOut_Message() {}

func (*CrdtStreamOut_StreamCancelledResponse) isCrdtStreamOut_Message() {}

func (*CrdtStreamOut_Failure) isCrdtStreamOut_Message() {}

func (m *CrdtStreamOut) GetMessage() isCrdtStreamOut_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *CrdtStreamOut) GetReply() *CrdtReply {
	if x, ok := m.GetMessage().(*CrdtStreamOut_Reply); ok {
		return x.Reply
	}
	return nil
}

func (m *CrdtStreamOut) GetStreamedMessage() *CrdtStreamedMessage {
	if x, ok := m.GetMessage().(*CrdtStreamOut_StreamedMessage); ok {
		return x.StreamedMessage
	}
	return nil
}

func (m *CrdtStreamOut) GetStreamCancelledResponse() *CrdtStreamCancelledResponse {
	if x, ok := m.GetMessage().(*CrdtStreamOut_StreamCancelledResponse); ok {
		return x.StreamCancelledResponse
	}
	return nil
}

func (m *CrdtStreamOut) GetFailure() *Failure {
	if x, ok := m.GetMessage().(*CrdtStreamOut_Failure); ok {
		return x.Failure
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrdtStreamOut) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrdtStreamOut_Reply)(nil),
		(*CrdtStreamOut_StreamedMessage)(nil),
		(*CrdtStreamOut_StreamCancelledResponse)(nil),
		(*CrdtStreamOut_Failure)(nil),
	}
}

// The CRDT state. This represents the full state of a CRDT. When received, a user function should replace the current
// state with this, not apply it as a delta. This includes both for the top level CRDT, and embedded CRDTs, such as
// the values of an ORMap.
type CrdtState struct {
	// Types that are valid to be assigned to State:
	//	*CrdtState_Gcounter
	//	*CrdtState_Pncounter
	//	*CrdtState_Gset
	//	*CrdtState_Orset
	//	*CrdtState_Lwwregister
	//	*CrdtState_Flag
	//	*CrdtState_Ormap
	//	*CrdtState_Vote
	State                isCrdtState_State `protobuf_oneof:"state"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *CrdtState) Reset()         { *m = CrdtState{} }
func (m *CrdtState) String() string { return proto.CompactTextString(m) }
func (*CrdtState) ProtoMessage()    {}
func (*CrdtState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{2}
}

func (m *CrdtState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtState.Unmarshal(m, b)
}
func (m *CrdtState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtState.Marshal(b, m, deterministic)
}
func (m *CrdtState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtState.Merge(m, src)
}
func (m *CrdtState) XXX_Size() int {
	return xxx_messageInfo_CrdtState.Size(m)
}
func (m *CrdtState) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtState.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtState proto.InternalMessageInfo

type isCrdtState_State interface {
	isCrdtState_State()
}

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

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

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

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

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

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

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

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

func (*CrdtState_Gcounter) isCrdtState_State() {}

func (*CrdtState_Pncounter) isCrdtState_State() {}

func (*CrdtState_Gset) isCrdtState_State() {}

func (*CrdtState_Orset) isCrdtState_State() {}

func (*CrdtState_Lwwregister) isCrdtState_State() {}

func (*CrdtState_Flag) isCrdtState_State() {}

func (*CrdtState_Ormap) isCrdtState_State() {}

func (*CrdtState_Vote) isCrdtState_State() {}

func (m *CrdtState) GetState() isCrdtState_State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *CrdtState) GetGcounter() *GCounterState {
	if x, ok := m.GetState().(*CrdtState_Gcounter); ok {
		return x.Gcounter
	}
	return nil
}

func (m *CrdtState) GetPncounter() *PNCounterState {
	if x, ok := m.GetState().(*CrdtState_Pncounter); ok {
		return x.Pncounter
	}
	return nil
}

func (m *CrdtState) GetGset() *GSetState {
	if x, ok := m.GetState().(*CrdtState_Gset); ok {
		return x.Gset
	}
	return nil
}

func (m *CrdtState) GetOrset() *ORSetState {
	if x, ok := m.GetState().(*CrdtState_Orset); ok {
		return x.Orset
	}
	return nil
}

func (m *CrdtState) GetLwwregister() *LWWRegisterState {
	if x, ok := m.GetState().(*CrdtState_Lwwregister); ok {
		return x.Lwwregister
	}
	return nil
}

func (m *CrdtState) GetFlag() *FlagState {
	if x, ok := m.GetState().(*CrdtState_Flag); ok {
		return x.Flag
	}
	return nil
}

func (m *CrdtState) GetOrmap() *ORMapState {
	if x, ok := m.GetState().(*CrdtState_Ormap); ok {
		return x.Ormap
	}
	return nil
}

func (m *CrdtState) GetVote() *VoteState {
	if x, ok := m.GetState().(*CrdtState_Vote); ok {
		return x.Vote
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrdtState) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrdtState_Gcounter)(nil),
		(*CrdtState_Pncounter)(nil),
		(*CrdtState_Gset)(nil),
		(*CrdtState_Orset)(nil),
		(*CrdtState_Lwwregister)(nil),
		(*CrdtState_Flag)(nil),
		(*CrdtState_Ormap)(nil),
		(*CrdtState_Vote)(nil),
	}
}

// A Grow-only counter
//
// A G-Counter can only be incremented, it can't be decremented.
type GCounterState struct {
	// The current value of the counter.
	Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GCounterState) Reset()         { *m = GCounterState{} }
func (m *GCounterState) String() string { return proto.CompactTextString(m) }
func (*GCounterState) ProtoMessage()    {}
func (*GCounterState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{3}
}

func (m *GCounterState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GCounterState.Unmarshal(m, b)
}
func (m *GCounterState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GCounterState.Marshal(b, m, deterministic)
}
func (m *GCounterState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GCounterState.Merge(m, src)
}
func (m *GCounterState) XXX_Size() int {
	return xxx_messageInfo_GCounterState.Size(m)
}
func (m *GCounterState) XXX_DiscardUnknown() {
	xxx_messageInfo_GCounterState.DiscardUnknown(m)
}

var xxx_messageInfo_GCounterState proto.InternalMessageInfo

func (m *GCounterState) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

// A Positive-Negative Counter
//
// A PN-Counter can be both incremented and decremented.
type PNCounterState struct {
	// The current value of the counter.
	Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PNCounterState) Reset()         { *m = PNCounterState{} }
func (m *PNCounterState) String() string { return proto.CompactTextString(m) }
func (*PNCounterState) ProtoMessage()    {}
func (*PNCounterState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{4}
}

func (m *PNCounterState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PNCounterState.Unmarshal(m, b)
}
func (m *PNCounterState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PNCounterState.Marshal(b, m, deterministic)
}
func (m *PNCounterState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PNCounterState.Merge(m, src)
}
func (m *PNCounterState) XXX_Size() int {
	return xxx_messageInfo_PNCounterState.Size(m)
}
func (m *PNCounterState) XXX_DiscardUnknown() {
	xxx_messageInfo_PNCounterState.DiscardUnknown(m)
}

var xxx_messageInfo_PNCounterState proto.InternalMessageInfo

func (m *PNCounterState) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

// A Grow-only Set
//
// A G-Set can only have items added, items cannot be removed.
type GSetState struct {
	// The current items in the set.
	Items                []*any.Any `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GSetState) Reset()         { *m = GSetState{} }
func (m *GSetState) String() string { return proto.CompactTextString(m) }
func (*GSetState) ProtoMessage()    {}
func (*GSetState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{5}
}

func (m *GSetState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GSetState.Unmarshal(m, b)
}
func (m *GSetState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GSetState.Marshal(b, m, deterministic)
}
func (m *GSetState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GSetState.Merge(m, src)
}
func (m *GSetState) XXX_Size() int {
	return xxx_messageInfo_GSetState.Size(m)
}
func (m *GSetState) XXX_DiscardUnknown() {
	xxx_messageInfo_GSetState.DiscardUnknown(m)
}

var xxx_messageInfo_GSetState proto.InternalMessageInfo

func (m *GSetState) GetItems() []*any.Any {
	if m != nil {
		return m.Items
	}
	return nil
}

// An Observed-Removed Set
//
// An OR-Set may have items added and removed, with the condition that an item must be observed to be in the set before
// it is removed.
type ORSetState struct {
	// The current items in the set.
	Items                []*any.Any `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ORSetState) Reset()         { *m = ORSetState{} }
func (m *ORSetState) String() string { return proto.CompactTextString(m) }
func (*ORSetState) ProtoMessage()    {}
func (*ORSetState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{6}
}

func (m *ORSetState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORSetState.Unmarshal(m, b)
}
func (m *ORSetState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORSetState.Marshal(b, m, deterministic)
}
func (m *ORSetState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORSetState.Merge(m, src)
}
func (m *ORSetState) XXX_Size() int {
	return xxx_messageInfo_ORSetState.Size(m)
}
func (m *ORSetState) XXX_DiscardUnknown() {
	xxx_messageInfo_ORSetState.DiscardUnknown(m)
}

var xxx_messageInfo_ORSetState proto.InternalMessageInfo

func (m *ORSetState) GetItems() []*any.Any {
	if m != nil {
		return m.Items
	}
	return nil
}

// A Last-Write-Wins Register
//
// A LWW-Register holds a single value, with the current value being selected based on when it was last written.
// The time of the last write may either be determined using the proxies clock, or may be based on a custom, domain
// specific value.
type LWWRegisterState struct {
	// The current value of the register.
	Value *any.Any `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// The clock to use if this state needs to be merged with another one.
	Clock CrdtClock `protobuf:"varint,2,opt,name=clock,proto3,enum=cloudstate.crdt.CrdtClock" json:"clock,omitempty"`
	// The clock value if the clock in use is a custom clock.
	CustomClockValue     int64    `protobuf:"varint,3,opt,name=custom_clock_value,json=customClockValue,proto3" json:"custom_clock_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LWWRegisterState) Reset()         { *m = LWWRegisterState{} }
func (m *LWWRegisterState) String() string { return proto.CompactTextString(m) }
func (*LWWRegisterState) ProtoMessage()    {}
func (*LWWRegisterState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{7}
}

func (m *LWWRegisterState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LWWRegisterState.Unmarshal(m, b)
}
func (m *LWWRegisterState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LWWRegisterState.Marshal(b, m, deterministic)
}
func (m *LWWRegisterState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LWWRegisterState.Merge(m, src)
}
func (m *LWWRegisterState) XXX_Size() int {
	return xxx_messageInfo_LWWRegisterState.Size(m)
}
func (m *LWWRegisterState) XXX_DiscardUnknown() {
	xxx_messageInfo_LWWRegisterState.DiscardUnknown(m)
}

var xxx_messageInfo_LWWRegisterState proto.InternalMessageInfo

func (m *LWWRegisterState) GetValue() *any.Any {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *LWWRegisterState) GetClock() CrdtClock {
	if m != nil {
		return m.Clock
	}
	return CrdtClock_DEFAULT
}

func (m *LWWRegisterState) GetCustomClockValue() int64 {
	if m != nil {
		return m.CustomClockValue
	}
	return 0
}

// A Flag
//
// A Flag is a boolean value, that once set to true, stays true.
type FlagState struct {
	// The current value of the flag.
	Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FlagState) Reset()         { *m = FlagState{} }
func (m *FlagState) String() string { return proto.CompactTextString(m) }
func (*FlagState) ProtoMessage()    {}
func (*FlagState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{8}
}

func (m *FlagState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FlagState.Unmarshal(m, b)
}
func (m *FlagState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FlagState.Marshal(b, m, deterministic)
}
func (m *FlagState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlagState.Merge(m, src)
}
func (m *FlagState) XXX_Size() int {
	return xxx_messageInfo_FlagState.Size(m)
}
func (m *FlagState) XXX_DiscardUnknown() {
	xxx_messageInfo_FlagState.DiscardUnknown(m)
}

var xxx_messageInfo_FlagState proto.InternalMessageInfo

func (m *FlagState) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

// An Observed-Removed Map
//
// Like an OR-Set, an OR-Map may have items added and removed, with the condition that an item must be observed to be
// in the map before it is removed. The values of the map are CRDTs themselves. Different keys are allowed to use
// different CRDTs, and if an item is removed, and then replaced, the new value may be a different CRDT.
type ORMapState struct {
	// The entries of the map.
	Entries              []*ORMapEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ORMapState) Reset()         { *m = ORMapState{} }
func (m *ORMapState) String() string { return proto.CompactTextString(m) }
func (*ORMapState) ProtoMessage()    {}
func (*ORMapState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{9}
}

func (m *ORMapState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORMapState.Unmarshal(m, b)
}
func (m *ORMapState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORMapState.Marshal(b, m, deterministic)
}
func (m *ORMapState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORMapState.Merge(m, src)
}
func (m *ORMapState) XXX_Size() int {
	return xxx_messageInfo_ORMapState.Size(m)
}
func (m *ORMapState) XXX_DiscardUnknown() {
	xxx_messageInfo_ORMapState.DiscardUnknown(m)
}

var xxx_messageInfo_ORMapState proto.InternalMessageInfo

func (m *ORMapState) GetEntries() []*ORMapEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

// An OR-Map entry.
type ORMapEntry struct {
	// The entry key.
	Key *any.Any `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The value of the entry, a CRDT itself.
	Value                *CrdtState `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ORMapEntry) Reset()         { *m = ORMapEntry{} }
func (m *ORMapEntry) String() string { return proto.CompactTextString(m) }
func (*ORMapEntry) ProtoMessage()    {}
func (*ORMapEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{10}
}

func (m *ORMapEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORMapEntry.Unmarshal(m, b)
}
func (m *ORMapEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORMapEntry.Marshal(b, m, deterministic)
}
func (m *ORMapEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORMapEntry.Merge(m, src)
}
func (m *ORMapEntry) XXX_Size() int {
	return xxx_messageInfo_ORMapEntry.Size(m)
}
func (m *ORMapEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_ORMapEntry.DiscardUnknown(m)
}

var xxx_messageInfo_ORMapEntry proto.InternalMessageInfo

func (m *ORMapEntry) GetKey() *any.Any {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ORMapEntry) GetValue() *CrdtState {
	if m != nil {
		return m.Value
	}
	return nil
}

// A Vote. This allows nodes to vote on something.
type VoteState struct {
	// The number of votes for
	VotesFor uint32 `protobuf:"varint,1,opt,name=votes_for,json=votesFor,proto3" json:"votes_for,omitempty"`
	// The total number of voters
	TotalVoters uint32 `protobuf:"varint,2,opt,name=total_voters,json=totalVoters,proto3" json:"total_voters,omitempty"`
	// The vote of the current node, which is included in the above two numbers
	SelfVote             bool     `protobuf:"varint,3,opt,name=self_vote,json=selfVote,proto3" json:"self_vote,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VoteState) Reset()         { *m = VoteState{} }
func (m *VoteState) String() string { return proto.CompactTextString(m) }
func (*VoteState) ProtoMessage()    {}
func (*VoteState) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{11}
}

func (m *VoteState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VoteState.Unmarshal(m, b)
}
func (m *VoteState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VoteState.Marshal(b, m, deterministic)
}
func (m *VoteState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteState.Merge(m, src)
}
func (m *VoteState) XXX_Size() int {
	return xxx_messageInfo_VoteState.Size(m)
}
func (m *VoteState) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteState.DiscardUnknown(m)
}

var xxx_messageInfo_VoteState proto.InternalMessageInfo

func (m *VoteState) GetVotesFor() uint32 {
	if m != nil {
		return m.VotesFor
	}
	return 0
}

func (m *VoteState) GetTotalVoters() uint32 {
	if m != nil {
		return m.TotalVoters
	}
	return 0
}

func (m *VoteState) GetSelfVote() bool {
	if m != nil {
		return m.SelfVote
	}
	return false
}

// A CRDT delta
//
// Deltas only carry the change in value, not the full value (unless
type CrdtDelta struct {
	// Types that are valid to be assigned to Delta:
	//	*CrdtDelta_Gcounter
	//	*CrdtDelta_Pncounter
	//	*CrdtDelta_Gset
	//	*CrdtDelta_Orset
	//	*CrdtDelta_Lwwregister
	//	*CrdtDelta_Flag
	//	*CrdtDelta_Ormap
	//	*CrdtDelta_Vote
	Delta                isCrdtDelta_Delta `protobuf_oneof:"delta"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *CrdtDelta) Reset()         { *m = CrdtDelta{} }
func (m *CrdtDelta) String() string { return proto.CompactTextString(m) }
func (*CrdtDelta) ProtoMessage()    {}
func (*CrdtDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{12}
}

func (m *CrdtDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtDelta.Unmarshal(m, b)
}
func (m *CrdtDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtDelta.Marshal(b, m, deterministic)
}
func (m *CrdtDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtDelta.Merge(m, src)
}
func (m *CrdtDelta) XXX_Size() int {
	return xxx_messageInfo_CrdtDelta.Size(m)
}
func (m *CrdtDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtDelta.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtDelta proto.InternalMessageInfo

type isCrdtDelta_Delta interface {
	isCrdtDelta_Delta()
}

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

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

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

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

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

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

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

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

func (*CrdtDelta_Gcounter) isCrdtDelta_Delta() {}

func (*CrdtDelta_Pncounter) isCrdtDelta_Delta() {}

func (*CrdtDelta_Gset) isCrdtDelta_Delta() {}

func (*CrdtDelta_Orset) isCrdtDelta_Delta() {}

func (*CrdtDelta_Lwwregister) isCrdtDelta_Delta() {}

func (*CrdtDelta_Flag) isCrdtDelta_Delta() {}

func (*CrdtDelta_Ormap) isCrdtDelta_Delta() {}

func (*CrdtDelta_Vote) isCrdtDelta_Delta() {}

func (m *CrdtDelta) GetDelta() isCrdtDelta_Delta {
	if m != nil {
		return m.Delta
	}
	return nil
}

func (m *CrdtDelta) GetGcounter() *GCounterDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Gcounter); ok {
		return x.Gcounter
	}
	return nil
}

func (m *CrdtDelta) GetPncounter() *PNCounterDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Pncounter); ok {
		return x.Pncounter
	}
	return nil
}

func (m *CrdtDelta) GetGset() *GSetDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Gset); ok {
		return x.Gset
	}
	return nil
}

func (m *CrdtDelta) GetOrset() *ORSetDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Orset); ok {
		return x.Orset
	}
	return nil
}

func (m *CrdtDelta) GetLwwregister() *LWWRegisterDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Lwwregister); ok {
		return x.Lwwregister
	}
	return nil
}

func (m *CrdtDelta) GetFlag() *FlagDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Flag); ok {
		return x.Flag
	}
	return nil
}

func (m *CrdtDelta) GetOrmap() *ORMapDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Ormap); ok {
		return x.Ormap
	}
	return nil
}

func (m *CrdtDelta) GetVote() *VoteDelta {
	if x, ok := m.GetDelta().(*CrdtDelta_Vote); ok {
		return x.Vote
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrdtDelta) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrdtDelta_Gcounter)(nil),
		(*CrdtDelta_Pncounter)(nil),
		(*CrdtDelta_Gset)(nil),
		(*CrdtDelta_Orset)(nil),
		(*CrdtDelta_Lwwregister)(nil),
		(*CrdtDelta_Flag)(nil),
		(*CrdtDelta_Ormap)(nil),
		(*CrdtDelta_Vote)(nil),
	}
}

type GCounterDelta struct {
	Increment            uint64   `protobuf:"varint,1,opt,name=increment,proto3" json:"increment,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GCounterDelta) Reset()         { *m = GCounterDelta{} }
func (m *GCounterDelta) String() string { return proto.CompactTextString(m) }
func (*GCounterDelta) ProtoMessage()    {}
func (*GCounterDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{13}
}

func (m *GCounterDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GCounterDelta.Unmarshal(m, b)
}
func (m *GCounterDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GCounterDelta.Marshal(b, m, deterministic)
}
func (m *GCounterDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GCounterDelta.Merge(m, src)
}
func (m *GCounterDelta) XXX_Size() int {
	return xxx_messageInfo_GCounterDelta.Size(m)
}
func (m *GCounterDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_GCounterDelta.DiscardUnknown(m)
}

var xxx_messageInfo_GCounterDelta proto.InternalMessageInfo

func (m *GCounterDelta) GetIncrement() uint64 {
	if m != nil {
		return m.Increment
	}
	return 0
}

type PNCounterDelta struct {
	Change               int64    `protobuf:"zigzag64,1,opt,name=change,proto3" json:"change,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PNCounterDelta) Reset()         { *m = PNCounterDelta{} }
func (m *PNCounterDelta) String() string { return proto.CompactTextString(m) }
func (*PNCounterDelta) ProtoMessage()    {}
func (*PNCounterDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{14}
}

func (m *PNCounterDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PNCounterDelta.Unmarshal(m, b)
}
func (m *PNCounterDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PNCounterDelta.Marshal(b, m, deterministic)
}
func (m *PNCounterDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PNCounterDelta.Merge(m, src)
}
func (m *PNCounterDelta) XXX_Size() int {
	return xxx_messageInfo_PNCounterDelta.Size(m)
}
func (m *PNCounterDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_PNCounterDelta.DiscardUnknown(m)
}

var xxx_messageInfo_PNCounterDelta proto.InternalMessageInfo

func (m *PNCounterDelta) GetChange() int64 {
	if m != nil {
		return m.Change
	}
	return 0
}

type GSetDelta struct {
	Added                []*any.Any `protobuf:"bytes,1,rep,name=added,proto3" json:"added,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GSetDelta) Reset()         { *m = GSetDelta{} }
func (m *GSetDelta) String() string { return proto.CompactTextString(m) }
func (*GSetDelta) ProtoMessage()    {}
func (*GSetDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{15}
}

func (m *GSetDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GSetDelta.Unmarshal(m, b)
}
func (m *GSetDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GSetDelta.Marshal(b, m, deterministic)
}
func (m *GSetDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GSetDelta.Merge(m, src)
}
func (m *GSetDelta) XXX_Size() int {
	return xxx_messageInfo_GSetDelta.Size(m)
}
func (m *GSetDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_GSetDelta.DiscardUnknown(m)
}

var xxx_messageInfo_GSetDelta proto.InternalMessageInfo

func (m *GSetDelta) GetAdded() []*any.Any {
	if m != nil {
		return m.Added
	}
	return nil
}

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"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ORSetDelta) Reset()         { *m = ORSetDelta{} }
func (m *ORSetDelta) String() string { return proto.CompactTextString(m) }
func (*ORSetDelta) ProtoMessage()    {}
func (*ORSetDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{16}
}

func (m *ORSetDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORSetDelta.Unmarshal(m, b)
}
func (m *ORSetDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORSetDelta.Marshal(b, m, deterministic)
}
func (m *ORSetDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORSetDelta.Merge(m, src)
}
func (m *ORSetDelta) XXX_Size() int {
	return xxx_messageInfo_ORSetDelta.Size(m)
}
func (m *ORSetDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_ORSetDelta.DiscardUnknown(m)
}

var xxx_messageInfo_ORSetDelta proto.InternalMessageInfo

func (m *ORSetDelta) GetCleared() bool {
	if m != nil {
		return m.Cleared
	}
	return false
}

func (m *ORSetDelta) GetRemoved() []*any.Any {
	if m != nil {
		return m.Removed
	}
	return nil
}

func (m *ORSetDelta) GetAdded() []*any.Any {
	if m != nil {
		return m.Added
	}
	return nil
}

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"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LWWRegisterDelta) Reset()         { *m = LWWRegisterDelta{} }
func (m *LWWRegisterDelta) String() string { return proto.CompactTextString(m) }
func (*LWWRegisterDelta) ProtoMessage()    {}
func (*LWWRegisterDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{17}
}

func (m *LWWRegisterDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LWWRegisterDelta.Unmarshal(m, b)
}
func (m *LWWRegisterDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LWWRegisterDelta.Marshal(b, m, deterministic)
}
func (m *LWWRegisterDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LWWRegisterDelta.Merge(m, src)
}
func (m *LWWRegisterDelta) XXX_Size() int {
	return xxx_messageInfo_LWWRegisterDelta.Size(m)
}
func (m *LWWRegisterDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_LWWRegisterDelta.DiscardUnknown(m)
}

var xxx_messageInfo_LWWRegisterDelta proto.InternalMessageInfo

func (m *LWWRegisterDelta) GetValue() *any.Any {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *LWWRegisterDelta) GetClock() CrdtClock {
	if m != nil {
		return m.Clock
	}
	return CrdtClock_DEFAULT
}

func (m *LWWRegisterDelta) GetCustomClockValue() int64 {
	if m != nil {
		return m.CustomClockValue
	}
	return 0
}

type FlagDelta struct {
	Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FlagDelta) Reset()         { *m = FlagDelta{} }
func (m *FlagDelta) String() string { return proto.CompactTextString(m) }
func (*FlagDelta) ProtoMessage()    {}
func (*FlagDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{18}
}

func (m *FlagDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FlagDelta.Unmarshal(m, b)
}
func (m *FlagDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FlagDelta.Marshal(b, m, deterministic)
}
func (m *FlagDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlagDelta.Merge(m, src)
}
func (m *FlagDelta) XXX_Size() int {
	return xxx_messageInfo_FlagDelta.Size(m)
}
func (m *FlagDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_FlagDelta.DiscardUnknown(m)
}

var xxx_messageInfo_FlagDelta proto.InternalMessageInfo

func (m *FlagDelta) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

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                []*ORMapEntry      `protobuf:"bytes,4,rep,name=added,proto3" json:"added,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ORMapDelta) Reset()         { *m = ORMapDelta{} }
func (m *ORMapDelta) String() string { return proto.CompactTextString(m) }
func (*ORMapDelta) ProtoMessage()    {}
func (*ORMapDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{19}
}

func (m *ORMapDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORMapDelta.Unmarshal(m, b)
}
func (m *ORMapDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORMapDelta.Marshal(b, m, deterministic)
}
func (m *ORMapDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORMapDelta.Merge(m, src)
}
func (m *ORMapDelta) XXX_Size() int {
	return xxx_messageInfo_ORMapDelta.Size(m)
}
func (m *ORMapDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_ORMapDelta.DiscardUnknown(m)
}

var xxx_messageInfo_ORMapDelta proto.InternalMessageInfo

func (m *ORMapDelta) GetCleared() bool {
	if m != nil {
		return m.Cleared
	}
	return false
}

func (m *ORMapDelta) GetRemoved() []*any.Any {
	if m != nil {
		return m.Removed
	}
	return nil
}

func (m *ORMapDelta) GetUpdated() []*ORMapEntryDelta {
	if m != nil {
		return m.Updated
	}
	return nil
}

func (m *ORMapDelta) GetAdded() []*ORMapEntry {
	if m != nil {
		return m.Added
	}
	return nil
}

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"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ORMapEntryDelta) Reset()         { *m = ORMapEntryDelta{} }
func (m *ORMapEntryDelta) String() string { return proto.CompactTextString(m) }
func (*ORMapEntryDelta) ProtoMessage()    {}
func (*ORMapEntryDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{20}
}

func (m *ORMapEntryDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ORMapEntryDelta.Unmarshal(m, b)
}
func (m *ORMapEntryDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ORMapEntryDelta.Marshal(b, m, deterministic)
}
func (m *ORMapEntryDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ORMapEntryDelta.Merge(m, src)
}
func (m *ORMapEntryDelta) XXX_Size() int {
	return xxx_messageInfo_ORMapEntryDelta.Size(m)
}
func (m *ORMapEntryDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_ORMapEntryDelta.DiscardUnknown(m)
}

var xxx_messageInfo_ORMapEntryDelta proto.InternalMessageInfo

func (m *ORMapEntryDelta) GetKey() *any.Any {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ORMapEntryDelta) GetDelta() *CrdtDelta {
	if m != nil {
		return m.Delta
	}
	return nil
}

type VoteDelta struct {
	// Only set by the user function to change the nodes current vote.
	SelfVote bool `protobuf:"varint,1,opt,name=self_vote,json=selfVote,proto3" json:"self_vote,omitempty"`
	// Only set by the proxy to change the votes for and total voters.
	VotesFor             int32    `protobuf:"varint,2,opt,name=votes_for,json=votesFor,proto3" json:"votes_for,omitempty"`
	TotalVoters          int32    `protobuf:"varint,3,opt,name=total_voters,json=totalVoters,proto3" json:"total_voters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VoteDelta) Reset()         { *m = VoteDelta{} }
func (m *VoteDelta) String() string { return proto.CompactTextString(m) }
func (*VoteDelta) ProtoMessage()    {}
func (*VoteDelta) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{21}
}

func (m *VoteDelta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VoteDelta.Unmarshal(m, b)
}
func (m *VoteDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VoteDelta.Marshal(b, m, deterministic)
}
func (m *VoteDelta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteDelta.Merge(m, src)
}
func (m *VoteDelta) XXX_Size() int {
	return xxx_messageInfo_VoteDelta.Size(m)
}
func (m *VoteDelta) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteDelta.DiscardUnknown(m)
}

var xxx_messageInfo_VoteDelta proto.InternalMessageInfo

func (m *VoteDelta) GetSelfVote() bool {
	if m != nil {
		return m.SelfVote
	}
	return false
}

func (m *VoteDelta) GetVotesFor() int32 {
	if m != nil {
		return m.VotesFor
	}
	return 0
}

func (m *VoteDelta) GetTotalVoters() int32 {
	if m != nil {
		return m.TotalVoters
	}
	return 0
}

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"`
	State                *CrdtState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *CrdtInit) Reset()         { *m = CrdtInit{} }
func (m *CrdtInit) String() string { return proto.CompactTextString(m) }
func (*CrdtInit) ProtoMessage()    {}
func (*CrdtInit) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{22}
}

func (m *CrdtInit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtInit.Unmarshal(m, b)
}
func (m *CrdtInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtInit.Marshal(b, m, deterministic)
}
func (m *CrdtInit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtInit.Merge(m, src)
}
func (m *CrdtInit) XXX_Size() int {
	return xxx_messageInfo_CrdtInit.Size(m)
}
func (m *CrdtInit) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtInit.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtInit proto.InternalMessageInfo

func (m *CrdtInit) GetServiceName() string {
	if m != nil {
		return m.ServiceName
	}
	return ""
}

func (m *CrdtInit) GetEntityId() string {
	if m != nil {
		return m.EntityId
	}
	return ""
}

func (m *CrdtInit) GetState() *CrdtState {
	if m != nil {
		return m.State
	}
	return nil
}

type CrdtDelete struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrdtDelete) Reset()         { *m = CrdtDelete{} }
func (m *CrdtDelete) String() string { return proto.CompactTextString(m) }
func (*CrdtDelete) ProtoMessage()    {}
func (*CrdtDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{23}
}

func (m *CrdtDelete) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtDelete.Unmarshal(m, b)
}
func (m *CrdtDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtDelete.Marshal(b, m, deterministic)
}
func (m *CrdtDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtDelete.Merge(m, src)
}
func (m *CrdtDelete) XXX_Size() int {
	return xxx_messageInfo_CrdtDelete.Size(m)
}
func (m *CrdtDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtDelete.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtDelete proto.InternalMessageInfo

type CrdtReply struct {
	CommandId    int64            `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	ClientAction *ClientAction    `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	SideEffects  []*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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrdtReply) Reset()         { *m = CrdtReply{} }
func (m *CrdtReply) String() string { return proto.CompactTextString(m) }
func (*CrdtReply) ProtoMessage()    {}
func (*CrdtReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{24}
}

func (m *CrdtReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtReply.Unmarshal(m, b)
}
func (m *CrdtReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtReply.Marshal(b, m, deterministic)
}
func (m *CrdtReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtReply.Merge(m, src)
}
func (m *CrdtReply) XXX_Size() int {
	return xxx_messageInfo_CrdtReply.Size(m)
}
func (m *CrdtReply) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtReply.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtReply proto.InternalMessageInfo

func (m *CrdtReply) GetCommandId() int64 {
	if m != nil {
		return m.CommandId
	}
	return 0
}

func (m *CrdtReply) GetClientAction() *ClientAction {
	if m != nil {
		return m.ClientAction
	}
	return nil
}

func (m *CrdtReply) GetSideEffects() []*SideEffect {
	if m != nil {
		return m.SideEffects
	}
	return nil
}

func (m *CrdtReply) GetStateAction() *CrdtStateAction {
	if m != nil {
		return m.StateAction
	}
	return nil
}

func (m *CrdtReply) GetStreamed() bool {
	if m != nil {
		return m.Streamed
	}
	return false
}

type CrdtStateAction struct {
	// Types that are valid to be assigned to Action:
	//	*CrdtStateAction_Create
	//	*CrdtStateAction_Update
	//	*CrdtStateAction_Delete
	Action               isCrdtStateAction_Action `protobuf_oneof:"action"`
	WriteConsistency     CrdtWriteConsistency     `protobuf:"varint,8,opt,name=write_consistency,json=writeConsistency,proto3,enum=cloudstate.crdt.CrdtWriteConsistency" json:"write_consistency,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *CrdtStateAction) Reset()         { *m = CrdtStateAction{} }
func (m *CrdtStateAction) String() string { return proto.CompactTextString(m) }
func (*CrdtStateAction) ProtoMessage()    {}
func (*CrdtStateAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{25}
}

func (m *CrdtStateAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtStateAction.Unmarshal(m, b)
}
func (m *CrdtStateAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtStateAction.Marshal(b, m, deterministic)
}
func (m *CrdtStateAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtStateAction.Merge(m, src)
}
func (m *CrdtStateAction) XXX_Size() int {
	return xxx_messageInfo_CrdtStateAction.Size(m)
}
func (m *CrdtStateAction) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtStateAction.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtStateAction proto.InternalMessageInfo

type isCrdtStateAction_Action interface {
	isCrdtStateAction_Action()
}

type CrdtStateAction_Create struct {
	Create *CrdtState `protobuf:"bytes,5,opt,name=create,proto3,oneof"`
}

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

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

func (*CrdtStateAction_Create) isCrdtStateAction_Action() {}

func (*CrdtStateAction_Update) isCrdtStateAction_Action() {}

func (*CrdtStateAction_Delete) isCrdtStateAction_Action() {}

func (m *CrdtStateAction) GetAction() isCrdtStateAction_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *CrdtStateAction) GetCreate() *CrdtState {
	if x, ok := m.GetAction().(*CrdtStateAction_Create); ok {
		return x.Create
	}
	return nil
}

func (m *CrdtStateAction) GetUpdate() *CrdtDelta {
	if x, ok := m.GetAction().(*CrdtStateAction_Update); ok {
		return x.Update
	}
	return nil
}

func (m *CrdtStateAction) GetDelete() *CrdtDelete {
	if x, ok := m.GetAction().(*CrdtStateAction_Delete); ok {
		return x.Delete
	}
	return nil
}

func (m *CrdtStateAction) GetWriteConsistency() CrdtWriteConsistency {
	if m != nil {
		return m.WriteConsistency
	}
	return CrdtWriteConsistency_LOCAL
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrdtStateAction) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrdtStateAction_Create)(nil),
		(*CrdtStateAction_Update)(nil),
		(*CrdtStateAction_Delete)(nil),
	}
}

// May be sent as often as liked if the first reply set streamed to true
type CrdtStreamedMessage struct {
	CommandId    int64         `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	ClientAction *ClientAction `protobuf:"bytes,2,opt,name=client_action,json=clientAction,proto3" json:"client_action,omitempty"`
	SideEffects  []*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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrdtStreamedMessage) Reset()         { *m = CrdtStreamedMessage{} }
func (m *CrdtStreamedMessage) String() string { return proto.CompactTextString(m) }
func (*CrdtStreamedMessage) ProtoMessage()    {}
func (*CrdtStreamedMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{26}
}

func (m *CrdtStreamedMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtStreamedMessage.Unmarshal(m, b)
}
func (m *CrdtStreamedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtStreamedMessage.Marshal(b, m, deterministic)
}
func (m *CrdtStreamedMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtStreamedMessage.Merge(m, src)
}
func (m *CrdtStreamedMessage) XXX_Size() int {
	return xxx_messageInfo_CrdtStreamedMessage.Size(m)
}
func (m *CrdtStreamedMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtStreamedMessage.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtStreamedMessage proto.InternalMessageInfo

func (m *CrdtStreamedMessage) GetCommandId() int64 {
	if m != nil {
		return m.CommandId
	}
	return 0
}

func (m *CrdtStreamedMessage) GetClientAction() *ClientAction {
	if m != nil {
		return m.ClientAction
	}
	return nil
}

func (m *CrdtStreamedMessage) GetSideEffects() []*SideEffect {
	if m != nil {
		return m.SideEffects
	}
	return nil
}

func (m *CrdtStreamedMessage) GetEndStream() bool {
	if m != nil {
		return m.EndStream
	}
	return false
}

type CrdtStreamCancelledResponse struct {
	CommandId            int64            `protobuf:"varint,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	SideEffects          []*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"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *CrdtStreamCancelledResponse) Reset()         { *m = CrdtStreamCancelledResponse{} }
func (m *CrdtStreamCancelledResponse) String() string { return proto.CompactTextString(m) }
func (*CrdtStreamCancelledResponse) ProtoMessage()    {}
func (*CrdtStreamCancelledResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c2f7bf98db4e2cd, []int{27}
}

func (m *CrdtStreamCancelledResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrdtStreamCancelledResponse.Unmarshal(m, b)
}
func (m *CrdtStreamCancelledResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrdtStreamCancelledResponse.Marshal(b, m, deterministic)
}
func (m *CrdtStreamCancelledResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrdtStreamCancelledResponse.Merge(m, src)
}
func (m *CrdtStreamCancelledResponse) XXX_Size() int {
	return xxx_messageInfo_CrdtStreamCancelledResponse.Size(m)
}
func (m *CrdtStreamCancelledResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrdtStreamCancelledResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrdtStreamCancelledResponse proto.InternalMessageInfo

func (m *CrdtStreamCancelledResponse) GetCommandId() int64 {
	if m != nil {
		return m.CommandId
	}
	return 0
}

func (m *CrdtStreamCancelledResponse) GetSideEffects() []*SideEffect {
	if m != nil {
		return m.SideEffects
	}
	return nil
}

func (m *CrdtStreamCancelledResponse) GetStateAction() *CrdtStateAction {
	if m != nil {
		return m.StateAction
	}
	return nil
}

func init() {
	proto.RegisterEnum("cloudstate.crdt.CrdtWriteConsistency", CrdtWriteConsistency_name, CrdtWriteConsistency_value)
	proto.RegisterEnum("cloudstate.crdt.CrdtClock", CrdtClock_name, CrdtClock_value)
	proto.RegisterType((*CrdtStreamIn)(nil), "cloudstate.crdt.CrdtStreamIn")
	proto.RegisterType((*CrdtStreamOut)(nil), "cloudstate.crdt.CrdtStreamOut")
	proto.RegisterType((*CrdtState)(nil), "cloudstate.crdt.CrdtState")
	proto.RegisterType((*GCounterState)(nil), "cloudstate.crdt.GCounterState")
	proto.RegisterType((*PNCounterState)(nil), "cloudstate.crdt.PNCounterState")
	proto.RegisterType((*GSetState)(nil), "cloudstate.crdt.GSetState")
	proto.RegisterType((*ORSetState)(nil), "cloudstate.crdt.ORSetState")
	proto.RegisterType((*LWWRegisterState)(nil), "cloudstate.crdt.LWWRegisterState")
	proto.RegisterType((*FlagState)(nil), "cloudstate.crdt.FlagState")
	proto.RegisterType((*ORMapState)(nil), "cloudstate.crdt.ORMapState")
	proto.RegisterType((*ORMapEntry)(nil), "cloudstate.crdt.ORMapEntry")
	proto.RegisterType((*VoteState)(nil), "cloudstate.crdt.VoteState")
	proto.RegisterType((*CrdtDelta)(nil), "cloudstate.crdt.CrdtDelta")
	proto.RegisterType((*GCounterDelta)(nil), "cloudstate.crdt.GCounterDelta")
	proto.RegisterType((*PNCounterDelta)(nil), "cloudstate.crdt.PNCounterDelta")
	proto.RegisterType((*GSetDelta)(nil), "cloudstate.crdt.GSetDelta")
	proto.RegisterType((*ORSetDelta)(nil), "cloudstate.crdt.ORSetDelta")
	proto.RegisterType((*LWWRegisterDelta)(nil), "cloudstate.crdt.LWWRegisterDelta")
	proto.RegisterType((*FlagDelta)(nil), "cloudstate.crdt.FlagDelta")
	proto.RegisterType((*ORMapDelta)(nil), "cloudstate.crdt.ORMapDelta")
	proto.RegisterType((*ORMapEntryDelta)(nil), "cloudstate.crdt.ORMapEntryDelta")
	proto.RegisterType((*VoteDelta)(nil), "cloudstate.crdt.VoteDelta")
	proto.RegisterType((*CrdtInit)(nil), "cloudstate.crdt.CrdtInit")
	proto.RegisterType((*CrdtDelete)(nil), "cloudstate.crdt.CrdtDelete")
	proto.RegisterType((*CrdtReply)(nil), "cloudstate.crdt.CrdtReply")
	proto.RegisterType((*CrdtStateAction)(nil), "cloudstate.crdt.CrdtStateAction")
	proto.RegisterType((*CrdtStreamedMessage)(nil), "cloudstate.crdt.CrdtStreamedMessage")
	proto.RegisterType((*CrdtStreamCancelledResponse)(nil), "cloudstate.crdt.CrdtStreamCancelledResponse")
}

func init() { proto.RegisterFile("crdt.proto", fileDescriptor_0c2f7bf98db4e2cd) }

var fileDescriptor_0c2f7bf98db4e2cd = []byte{
	// 1426 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
	0x14, 0xb6, 0xbd, 0xf1, 0xcf, 0x1e, 0x3b, 0x8d, 0x99, 0x96, 0xe2, 0xa4, 0xb4, 0xa4, 0x2b, 0x5a,
	0x45, 0x51, 0xeb, 0x94, 0x94, 0xd2, 0x82, 0x40, 0xc8, 0x71, 0x9d, 0xc6, 0xe0, 0xc4, 0x30, 0x49,
	0x53, 0xc1, 0xcd, 0x6a, 0xbb, 0x3b, 0x76, 0x97, 0xae, 0x67, 0xad, 0xdd, 0x71, 0xa2, 0x48, 0x5c,
	0x21, 0xf1, 0x02, 0x3c, 0x00, 0x4f, 0x82, 0xb8, 0xe3, 0x92, 0x17, 0xe0, 0x11, 0x78, 0x0a, 0x34,
	0x7f, 0xeb, 0x9f, 0xd8, 0x4e, 0x1c, 0x21, 0xc4, 0x9d, 0xe7, 0xcc, 0xf7, 0xcd, 0x39, 0x73, 0xce,
	0xf1, 0x37, 0x7b, 0x00, 0xdc, 0xc8, 0x63, 0xd5, 0x7e, 0x14, 0xb2, 0x10, 0xad, 0xb8, 0x41, 0x38,
	0xf0, 0x62, 0xe6, 0x30, 0x52, 0xe5, 0xe6, 0xb5, 0xd5, 0x6e, 0x18, 0x76, 0x03, 0xb2, 0x25, 0xb6,
	0x5f, 0x0f, 0x3a, 0x5b, 0x0e, 0x3d, 0x93, 0xd8, 0xb5, 0x12, 0xa1, 0xcc, 0x67, 0x6a, 0x65, 0xfd,
	0x9d, 0x81, 0x52, 0x3d, 0xf2, 0xd8, 0x21, 0x8b, 0x88, 0xd3, 0x6b, 0x52, 0xb4, 0x05, 0x4b, 0x3e,
	0xf5, 0x59, 0x25, 0xbd, 0x9e, 0xde, 0x28, 0x6e, 0xaf, 0x56, 0x27, 0x4e, 0xae, 0x72, 0x70, 0x93,
	0xfa, 0x6c, 0x2f, 0x85, 0x05, 0x10, 0x6d, 0x43, 0x56, 0x6c, 0x57, 0x32, 0x82, 0xb1, 0x36, 0x95,
	0x71, 0xc8, 0x97, 0x7b, 0x29, 0x2c, 0xa1, 0xe8, 0x13, 0xc8, 0xbb, 0x6f, 0x1c, 0xda, 0x25, 0x5e,
	0xc5, 0x98, 0xc3, 0x7a, 0x4e, 0x02, 0xe6, 0xec, 0xa5, 0xb0, 0x06, 0xa3, 0xa7, 0x90, 0xf7, 0x48,
	0x40, 0x18, 0xf1, 0x2a, 0x4b, 0x82, 0x77, 0x6b, 0x16, 0x8f, 0x08, 0x77, 0x1a, 0x8d, 0xb6, 0x20,
	0xef, 0x86, 0xbd, 0x9e, 0x43, 0xbd, 0x4a, 0x56, 0x10, 0xaf, 0x8f, 0x12, 0xeb, 0x72, 0x4b, 0x78,
	0x92, 0x3f, 0xd1, 0x1e, 0x94, 0x63, 0x91, 0x12, 0xdb, 0x75, 0xa8, 0x4b, 0x82, 0x80, 0x78, 0x95,
	0xdc, 0x79, 0x97, 0x32, 0x6d, 0x75, 0x0d, 0xd9, 0x4b, 0xe1, 0x95, 0x78, 0xdc, 0xb4, 0x63, 0x42,
	0xbe, 0x47, 0xe2, 0xd8, 0xe9, 0x12, 0xeb, 0xf7, 0x0c, 0x2c, 0x0f, 0x93, 0xdd, 0x1e, 0x88, 0xe4,
	0x45, 0xa4, 0x1f, 0x9c, 0xa9, 0x74, 0x4f, 0x4f, 0x03, 0xe6, 0x08, 0x9e, 0x3c, 0x01, 0x45, 0xdf,
	0xea, 0xd0, 0x88, 0x67, 0xab, 0x93, 0x55, 0xee, 0x3f, 0x9c, 0x91, 0x7b, 0x09, 0xde, 0x97, 0xd8,
	0x61, 0x8c, 0x89, 0x09, 0xfd, 0x00, 0xab, 0x93, 0xb7, 0xb5, 0x23, 0x12, 0xf7, 0x43, 0x1a, 0x13,
	0x55, 0xa1, 0x07, 0x73, 0xce, 0x4e, 0x2e, 0x8b, 0x15, 0x67, 0x2f, 0x85, 0xdf, 0x8b, 0xa7, 0x6f,
	0xf1, 0x52, 0x74, 0x1c, 0x3f, 0x18, 0x44, 0x44, 0xd5, 0x70, 0xac, 0x14, 0xbb, 0x72, 0x8b, 0x97,
	0x42, 0xa1, 0x46, 0x13, 0xf8, 0x97, 0x01, 0x66, 0xd2, 0x4e, 0xe8, 0x73, 0x28, 0x74, 0xdd, 0x70,
	0x40, 0x19, 0x89, 0x54, 0xfe, 0xee, 0x9c, 0x0b, 0xf2, 0x45, 0x5d, 0x02, 0x74, 0x03, 0x26, 0x0c,
	0xf4, 0x25, 0x98, 0x7d, 0xaa, 0xe9, 0x32, 0x7f, 0x1f, 0x9c, 0xa3, 0x7f, 0x73, 0x30, 0xc1, 0x1f,
	0x72, 0xd0, 0x23, 0x58, 0xea, 0xc6, 0x84, 0xcd, 0xec, 0xe0, 0x17, 0x87, 0x24, 0xe9, 0x7b, 0x81,
	0x44, 0x8f, 0x21, 0x1b, 0x46, 0x9c, 0x32, 0xab, 0x79, 0xdb, 0x78, 0x84, 0x23, 0xb1, 0xa8, 0x01,
	0xc5, 0xe0, 0xf4, 0x34, 0x22, 0x5d, 0x3f, 0xe6, 0x91, 0xca, 0xf6, 0xbd, 0x7b, 0x8e, 0xda, 0x7a,
	0xf5, 0x0a, 0x2b, 0x8c, 0x3e, 0x60, 0x94, 0xc7, 0xa3, 0xed, 0x04, 0x4e, 0x57, 0x35, 0xf1, 0xf9,
	0x68, 0x77, 0x03, 0xa7, 0x9b, 0x44, 0xcb, 0x91, 0x32, 0xda, 0x9e, 0xd3, 0xaf, 0xe4, 0x67, 0x46,
	0xbb, 0xef, 0xf4, 0x47, 0xa2, 0xed, 0x39, 0x7d, 0xee, 0xe6, 0x24, 0x64, 0xa4, 0x52, 0x98, 0xe1,
	0xe6, 0x38, 0x64, 0x24, 0x71, 0xc3, 0x91, 0x3b, 0x79, 0xa5, 0x1f, 0xd6, 0x3d, 0x58, 0x1e, 0xab,
	0x16, 0xba, 0x01, 0xd9, 0x13, 0x27, 0x18, 0x10, 0x51, 0xdc, 0x25, 0x2c, 0x17, 0xd6, 0x7d, 0xb8,
	0x36, 0x5e, 0x95, 0x71, 0x9c, 0xa1, 0x71, 0x4f, 0xc1, 0x4c, 0x2a, 0x80, 0x36, 0x21, 0xeb, 0x33,
	0xd2, 0x8b, 0x2b, 0xe9, 0x75, 0x63, 0xa3, 0xb8, 0x7d, 0xa3, 0x2a, 0xf5, 0xb1, 0xaa, 0xf5, 0xb1,
	0x5a, 0xa3, 0x67, 0x58, 0x42, 0xac, 0x67, 0x00, 0xc3, 0x3a, 0x2c, 0xc4, 0xfc, 0x35, 0x0d, 0xe5,
	0xc9, 0x3a, 0xf0, 0x03, 0x86, 0xd1, 0xcd, 0x3c, 0x40, 0x40, 0xd0, 0x23, 0xc8, 0xba, 0x41, 0xe8,
	0xbe, 0x15, 0xfd, 0x78, 0x6d, 0x86, 0x1c, 0xd4, 0x39, 0x02, 0x4b, 0x20, 0x7a, 0x00, 0xc8, 0x1d,
	0xc4, 0x2c, 0xec, 0xd9, 0x62, 0x6d, 0x4b, 0x57, 0x86, 0x48, 0x44, 0x59, 0xee, 0x08, 0xfc, 0xb1,
	0xc8, 0xc9, 0x5d, 0x30, 0x93, 0x3a, 0x8f, 0xa7, 0xad, 0xa0, 0xd3, 0x56, 0xe7, 0xb7, 0xd7, 0x75,
	0x45, 0x4f, 0x20, 0x4f, 0x28, 0x8b, 0x7c, 0xa2, 0xef, 0x3f, 0xa3, 0x0b, 0x1a, 0x94, 0x45, 0x67,
	0x58, 0x63, 0xad, 0x8e, 0x3a, 0x44, 0x98, 0xd1, 0x7d, 0x30, 0xde, 0x92, 0xb3, 0xb9, 0xf7, 0xe7,
	0x00, 0x7e, 0x7b, 0x19, 0xd0, 0x85, 0x2f, 0x89, 0x0e, 0xf6, 0x0d, 0x98, 0x49, 0x43, 0xa1, 0x5b,
	0x60, 0xf2, 0x86, 0x8a, 0xed, 0x4e, 0x28, 0xf5, 0x60, 0x19, 0x17, 0x84, 0x61, 0x37, 0x8c, 0xd0,
	0x5d, 0x28, 0xb1, 0x90, 0x39, 0x81, 0xcd, 0x2d, 0x51, 0x2c, 0x5c, 0x2c, 0xe3, 0xa2, 0xb0, 0x1d,
	0x0b, 0x13, 0xe7, 0xc7, 0x24, 0xe8, 0x08, 0x84, 0xc8, 0x60, 0x01, 0x17, 0xb8, 0x81, 0x6f, 0x27,
	0xca, 0x23, 0x9e, 0xa4, 0x85, 0x94, 0x47, 0x3f, 0x62, 0x57, 0x55, 0x1e, 0xcd, 0x5f, 0x50, 0x79,
	0x34, 0x6d, 0x11, 0xe5, 0xd1, 0x9c, 0x2b, 0x2b, 0x8f, 0x3e, 0x60, 0x61, 0xe5, 0x49, 0xa2, 0x5d,
	0x40, 0x79, 0x46, 0xa2, 0xbd, 0xac, 0xf2, 0x24, 0x6e, 0xb4, 0xf2, 0x78, 0xdc, 0x60, 0x3d, 0x1c,
	0x2a, 0x8f, 0xac, 0xef, 0xfb, 0x60, 0xfa, 0xd4, 0x8d, 0x48, 0x8f, 0x50, 0xa6, 0xd4, 0x67, 0x68,
	0xb0, 0x36, 0x46, 0x14, 0x48, 0xe2, 0x6f, 0x42, 0x4e, 0x7e, 0xa2, 0x08, 0x30, 0xc2, 0x6a, 0xa5,
	0x35, 0x48, 0x82, 0x36, 0x21, 0xeb, 0x78, 0x1e, 0xf1, 0xe6, 0x2b, 0x89, 0x80, 0x58, 0x3f, 0xa5,
	0x95, 0x08, 0x49, 0x6a, 0x05, 0xf2, 0x6e, 0x40, 0x9c, 0x48, 0x90, 0x79, 0x63, 0xea, 0x25, 0xaa,
	0x42, 0x3e, 0x22, 0xbd, 0xf0, 0x84, 0x78, 0x95, 0xcc, 0x9c, 0x63, 0x35, 0x68, 0x18, 0x84, 0x71,
	0x71, 0x10, 0x13, 0x72, 0x96, 0xdc, 0xe2, 0xff, 0x26, 0x67, 0x32, 0xb0, 0xe9, 0x72, 0xf6, 0x47,
	0x5a, 0x49, 0xd1, 0xbf, 0x9d, 0xc8, 0xcf, 0x20, 0x3f, 0xe8, 0x7b, 0x0e, 0x4b, 0x52, 0xb9, 0x3e,
	0x47, 0x19, 0x85, 0x73, 0xac, 0x09, 0xe8, 0x23, 0x5d, 0x84, 0xa5, 0x8b, 0x35, 0x55, 0xd5, 0xe2,
	0x2d, 0xac, 0x4c, 0x1c, 0xb7, 0x88, 0xac, 0x8a, 0x36, 0x9f, 0x2b, 0xab, 0x32, 0x42, 0xf5, 0x7f,
	0x50, 0xb2, 0x2a, 0xdd, 0x8c, 0xc9, 0x62, 0x7a, 0x5c, 0x16, 0xc7, 0x35, 0x97, 0x9f, 0x9f, 0x9d,
	0xa3, 0xb9, 0x86, 0xd8, 0x1f, 0xd5, 0x5c, 0xeb, 0x47, 0x28, 0xe8, 0x81, 0x82, 0xc3, 0x63, 0x12,
	0x9d, 0xf8, 0x2e, 0xb1, 0xa9, 0xd3, 0x93, 0xbe, 0x4c, 0x5c, 0x54, 0xb6, 0x03, 0xa7, 0x27, 0xdc,
	0xc9, 0xe9, 0xc5, 0xf6, 0x3d, 0xe1, 0xce, 0xc4, 0x05, 0x69, 0x68, 0x7a, 0xfc, 0x9e, 0x72, 0x10,
	0x31, 0x2e, 0x7e, 0x3e, 0xe4, 0x17, 0x47, 0x09, 0x60, 0x38, 0x2e, 0x58, 0x3f, 0x67, 0xa4, 0xc4,
	0x8b, 0xcf, 0x6d, 0x74, 0x1b, 0x40, 0xcd, 0x02, 0xdc, 0x97, 0xfc, 0xb2, 0x30, 0x95, 0xa5, 0xe9,
	0xa1, 0x2f, 0x60, 0xd9, 0x0d, 0x7c, 0x42, 0x99, 0xed, 0xb8, 0xcc, 0x0f, 0xa9, 0x4a, 0x6e, 0x65,
	0x6c, 0xac, 0x10, 0x80, 0x9a, 0xd8, 0xc7, 0x25, 0x77, 0x64, 0x85, 0x3e, 0x85, 0x52, 0xec, 0x7b,
	0xc4, 0x26, 0x9d, 0x0e, 0x71, 0x59, 0xac, 0x1a, 0xe1, 0xe6, 0xd8, 0x68, 0xe1, 0x7b, 0xa4, 0x21,
	0xb6, 0x71, 0x31, 0x4e, 0x7e, 0xc7, 0xa8, 0x0e, 0x25, 0x01, 0xd0, 0x8e, 0xa5, 0x2c, 0xaf, 0xcf,
	0xbe, 0xad, 0x0a, 0xa0, 0x18, 0x0f, 0x17, 0x68, 0x0d, 0x0a, 0x7a, 0x06, 0x10, 0xba, 0xcc, 0x6b,
	0xaa, 0xd6, 0xd6, 0x2f, 0x19, 0x58, 0x99, 0x20, 0xa3, 0x8f, 0x21, 0xe7, 0x46, 0x84, 0x27, 0x37,
	0x7b, 0x89, 0x29, 0x4f, 0x61, 0x39, 0x4b, 0xb6, 0xfc, 0x4c, 0xed, 0x1f, 0x9d, 0xf2, 0x14, 0x16,
	0x3d, 0x81, 0x9c, 0x1c, 0xdb, 0x66, 0xca, 0xff, 0xd8, 0x8c, 0xa7, 0xc0, 0x08, 0xc3, 0x3b, 0xa7,
	0x91, 0xcf, 0x88, 0xed, 0x86, 0x34, 0xe6, 0x82, 0x45, 0xdd, 0x33, 0xf1, 0x18, 0x5c, 0xdb, 0xbe,
	0x37, 0xf5, 0x84, 0x57, 0x1c, 0x5d, 0x1f, 0x82, 0x71, 0xf9, 0x74, 0xc2, 0xb2, 0x53, 0x80, 0x9c,
	0xcc, 0xb2, 0xf5, 0x67, 0x1a, 0xae, 0x4f, 0x19, 0xa6, 0xfe, 0xe3, 0x36, 0x31, 0x2e, 0xdf, 0x26,
	0xb7, 0x01, 0x08, 0xf5, 0x6c, 0x59, 0x55, 0xf1, 0xec, 0x17, 0xb0, 0x49, 0xa8, 0x27, 0x2f, 0x60,
	0xfd, 0x96, 0x86, 0x5b, 0x73, 0x06, 0xb8, 0x8b, 0xee, 0x35, 0x19, 0x58, 0xe6, 0xea, 0xfd, 0x6b,
	0x5c, 0xa1, 0x7f, 0x37, 0x9f, 0xc1, 0x8d, 0x69, 0x25, 0x44, 0x26, 0x64, 0x5b, 0xed, 0x7a, 0xad,
	0x55, 0x4e, 0xa1, 0x12, 0x14, 0xf6, 0x6b, 0x5f, 0xb5, 0x71, 0xf3, 0xe8, 0xbb, 0x72, 0x1a, 0xe5,
	0xc1, 0xa8, 0xb5, 0x5a, 0xe5, 0xcc, 0x66, 0x4b, 0xfe, 0xc9, 0xc5, 0x2b, 0x82, 0x8a, 0x90, 0x7f,
	0xde, 0xd8, 0xad, 0xbd, 0x6c, 0x1d, 0x95, 0x53, 0x7c, 0x81, 0x1b, 0xc7, 0x0d, 0x7c, 0xd8, 0x28,
	0xa7, 0x11, 0x40, 0xae, 0xfe, 0xf2, 0xf0, 0xa8, 0xbd, 0x5f, 0xce, 0xa0, 0x55, 0x78, 0x57, 0xfe,
	0xb6, 0x6b, 0x2f, 0x8f, 0xda, 0x76, 0xf3, 0xa0, 0x8e, 0x1b, 0xfb, 0x8d, 0x83, 0xa3, 0xb2, 0xb1,
	0x7d, 0x08, 0x4b, 0xfc, 0x34, 0xf4, 0x35, 0xe4, 0xde, 0x38, 0xd4, 0x0b, 0x08, 0xba, 0x3d, 0x67,
	0x4e, 0x6e, 0xd2, 0xb5, 0x3b, 0x73, 0xb6, 0xdb, 0x03, 0xb6, 0x91, 0x7e, 0x94, 0xde, 0x79, 0x08,
	0x37, 0xfd, 0x70, 0x14, 0x27, 0x34, 0xdd, 0x0d, 0x83, 0xef, 0xaf, 0x0f, 0x8d, 0x5b, 0xda, 0xf8,
	0x3a, 0x27, 0x7e, 0x3d, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0x36, 0x1b, 0xb2, 0x95, 0x11, 0x12,
	0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CrdtClient is the client API for Crdt service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
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, the current state of the entity. After that, one or more commands may be sent,
	// as well as deltas as they arrive, and the entire state if either the entity is created, or the proxy wishes the
	// user function to replace its entire state.
	//
	// 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 crdtClient struct {
	cc *grpc.ClientConn
}

func NewCrdtClient(cc *grpc.ClientConn) CrdtClient {
	return &crdtClient{cc}
}

func (c *crdtClient) Handle(ctx context.Context, opts ...grpc.CallOption) (Crdt_HandleClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Crdt_serviceDesc.Streams[0], "/cloudstate.crdt.Crdt/handle", opts...)
	if err != nil {
		return nil, err
	}
	x := &crdtHandleClient{stream}
	return x, nil
}

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

type crdtHandleClient struct {
	grpc.ClientStream
}

func (x *crdtHandleClient) Send(m *CrdtStreamIn) error {
	return x.ClientStream.SendMsg(m)
}

func (x *crdtHandleClient) Recv() (*CrdtStreamOut, error) {
	m := new(CrdtStreamOut)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// CrdtServer is the server API for Crdt service.
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, the current state of the entity. After that, one or more commands may be sent,
	// as well as deltas as they arrive, and the entire state if either the entity is created, or the proxy wishes the
	// user function to replace its entire state.
	//
	// 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
}

// UnimplementedCrdtServer can be embedded to have forward compatible implementations.
type UnimplementedCrdtServer struct {
}

func (*UnimplementedCrdtServer) Handle(srv Crdt_HandleServer) error {
	return status.Errorf(codes.Unimplemented, "method Handle not implemented")
}

func RegisterCrdtServer(s *grpc.Server, srv CrdtServer) {
	s.RegisterService(&_Crdt_serviceDesc, srv)
}

func _Crdt_Handle_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CrdtServer).Handle(&crdtHandleServer{stream})
}

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

type crdtHandleServer struct {
	grpc.ServerStream
}

func (x *crdtHandleServer) Send(m *CrdtStreamOut) error {
	return x.ServerStream.SendMsg(m)
}

func (x *crdtHandleServer) Recv() (*CrdtStreamIn, error) {
	m := new(CrdtStreamIn)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Crdt_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cloudstate.crdt.Crdt",
	HandlerType: (*CrdtServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "handle",
			Handler:       _Crdt_Handle_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "crdt.proto",
}