func (*ProcedureWALTrailer) Descriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{4}
}
Deprecated: Use ProcedureWALTrailer.ProtoReflect.Descriptor instead.
package pb
import (
	proto "github.com/golang/protobuf/proto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)
const (
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
const _ = proto.ProtoPackageIsVersion4
type ProcedureState int32
const (
	ProcedureState_INITIALIZING    ProcedureState = 1  
	ProcedureState_RUNNABLE        ProcedureState = 2  
	ProcedureState_WAITING         ProcedureState = 3  
	ProcedureState_WAITING_TIMEOUT ProcedureState = 4  
	ProcedureState_ROLLEDBACK      ProcedureState = 5  
	ProcedureState_FINISHED        ProcedureState = 6  
)
var (
	ProcedureState_name = map[int32]string{
		1: "INITIALIZING",
		2: "RUNNABLE",
		3: "WAITING",
		4: "WAITING_TIMEOUT",
		5: "ROLLEDBACK",
		6: "FINISHED",
	}
	ProcedureState_value = map[string]int32{
		"INITIALIZING":    1,
		"RUNNABLE":        2,
		"WAITING":         3,
		"WAITING_TIMEOUT": 4,
		"ROLLEDBACK":      5,
		"FINISHED":        6,
	}
)
func (x ProcedureState) Enum() *ProcedureState {
	p := new(ProcedureState)
	*p = x
	return p
}
func (x ProcedureState) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ProcedureState) Descriptor() protoreflect.EnumDescriptor {
	return file_Procedure_proto_enumTypes[0].Descriptor()
}
func (ProcedureState) Type() protoreflect.EnumType {
	return &file_Procedure_proto_enumTypes[0]
}
func (x ProcedureState) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (x *ProcedureState) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = ProcedureState(num)
	return nil
}
func (ProcedureState) EnumDescriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{0}
}
type ProcedureWALEntry_Type int32
const (
	ProcedureWALEntry_PROCEDURE_WAL_EOF     ProcedureWALEntry_Type = 1
	ProcedureWALEntry_PROCEDURE_WAL_INIT    ProcedureWALEntry_Type = 2
	ProcedureWALEntry_PROCEDURE_WAL_INSERT  ProcedureWALEntry_Type = 3
	ProcedureWALEntry_PROCEDURE_WAL_UPDATE  ProcedureWALEntry_Type = 4
	ProcedureWALEntry_PROCEDURE_WAL_DELETE  ProcedureWALEntry_Type = 5
	ProcedureWALEntry_PROCEDURE_WAL_COMPACT ProcedureWALEntry_Type = 6
)
var (
	ProcedureWALEntry_Type_name = map[int32]string{
		1: "PROCEDURE_WAL_EOF",
		2: "PROCEDURE_WAL_INIT",
		3: "PROCEDURE_WAL_INSERT",
		4: "PROCEDURE_WAL_UPDATE",
		5: "PROCEDURE_WAL_DELETE",
		6: "PROCEDURE_WAL_COMPACT",
	}
	ProcedureWALEntry_Type_value = map[string]int32{
		"PROCEDURE_WAL_EOF":     1,
		"PROCEDURE_WAL_INIT":    2,
		"PROCEDURE_WAL_INSERT":  3,
		"PROCEDURE_WAL_UPDATE":  4,
		"PROCEDURE_WAL_DELETE":  5,
		"PROCEDURE_WAL_COMPACT": 6,
	}
)
func (x ProcedureWALEntry_Type) Enum() *ProcedureWALEntry_Type {
	p := new(ProcedureWALEntry_Type)
	*p = x
	return p
}
func (x ProcedureWALEntry_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ProcedureWALEntry_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_Procedure_proto_enumTypes[1].Descriptor()
}
func (ProcedureWALEntry_Type) Type() protoreflect.EnumType {
	return &file_Procedure_proto_enumTypes[1]
}
func (x ProcedureWALEntry_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}
func (x *ProcedureWALEntry_Type) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = ProcedureWALEntry_Type(num)
	return nil
}
func (ProcedureWALEntry_Type) EnumDescriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{6, 0}
}
type Procedure struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	ClassName *string `protobuf:"bytes,1,req,name=class_name,json=className" json:"class_name,omitempty"`  
	ParentId  *uint64 `protobuf:"varint,2,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`    
	ProcId    *uint64 `protobuf:"varint,3,req,name=proc_id,json=procId" json:"proc_id,omitempty"`
	StartTime *uint64 `protobuf:"varint,4,req,name=start_time,json=startTime" json:"start_time,omitempty"`
	Owner     *string `protobuf:"bytes,5,opt,name=owner" json:"owner,omitempty"`
	State      *ProcedureState `protobuf:"varint,6,req,name=state,enum=pb.ProcedureState" json:"state,omitempty"`
	StackId    []uint32        `protobuf:"varint,7,rep,name=stack_id,json=stackId" json:"stack_id,omitempty"`  
	LastUpdate *uint64         `protobuf:"varint,8,req,name=last_update,json=lastUpdate" json:"last_update,omitempty"`
	Timeout    *uint32         `protobuf:"varint,9,opt,name=timeout" json:"timeout,omitempty"`
	Exception *ForeignExceptionMessage `protobuf:"bytes,10,opt,name=exception" json:"exception,omitempty"`
	Result    []byte                   `protobuf:"bytes,11,opt,name=result" json:"result,omitempty"`                         
	StateData []byte                   `protobuf:"bytes,12,opt,name=state_data,json=stateData" json:"state_data,omitempty"`  
	NonceGroup *uint64 `protobuf:"varint,13,opt,name=nonce_group,json=nonceGroup,def=0" json:"nonce_group,omitempty"`
	Nonce      *uint64 `protobuf:"varint,14,opt,name=nonce,def=0" json:"nonce,omitempty"`
}
const (
	Default_Procedure_NonceGroup = uint64(0)
	Default_Procedure_Nonce      = uint64(0)
)
func (x *Procedure) Reset() {
	*x = Procedure{}
	if protoimpl.UnsafeEnabled {
		mi := &file_Procedure_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *Procedure) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*Procedure) ProtoMessage() {}
func (x *Procedure) ProtoReflect() protoreflect.Message {
	mi := &file_Procedure_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*Procedure) Descriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{0}
}
func (x *Procedure) GetClassName() string {
	if x != nil && x.ClassName != nil {
		return *x.ClassName
	}
	return ""
}
func (x *Procedure) GetParentId() uint64 {
	if x != nil && x.ParentId != nil {
		return *x.ParentId
	}
	return 0
}
func (x *Procedure) GetProcId() uint64 {
	if x != nil && x.ProcId != nil {
		return *x.ProcId
	}
	return 0
}
func (x *Procedure) GetStartTime() uint64 {
	if x != nil && x.StartTime != nil {
		return *x.StartTime
	}
	return 0
}
func (x *Procedure) GetOwner() string {
	if x != nil && x.Owner != nil {
		return *x.Owner
	}
	return ""
}
func (x *Procedure) GetState() ProcedureState {
	if x != nil && x.State != nil {
		return *x.State
	}
	return ProcedureState_INITIALIZING
}
func (x *Procedure) GetStackId() []uint32 {
	if x != nil {
		return x.StackId
	}
	return nil
}
func (x *Procedure) GetLastUpdate() uint64 {
	if x != nil && x.LastUpdate != nil {
		return *x.LastUpdate
	}
	return 0
}
func (x *Procedure) GetTimeout() uint32 {
	if x != nil && x.Timeout != nil {
		return *x.Timeout
	}
	return 0
}
func (x *Procedure) GetException() *ForeignExceptionMessage {
	if x != nil {
		return x.Exception
	}
	return nil
}
func (x *Procedure) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}
func (x *Procedure) GetStateData() []byte {
	if x != nil {
		return x.StateData
	}
	return nil
}
func (x *Procedure) GetNonceGroup() uint64 {
	if x != nil && x.NonceGroup != nil {
		return *x.NonceGroup
	}
	return Default_Procedure_NonceGroup
}
func (x *Procedure) GetNonce() uint64 {
	if x != nil && x.Nonce != nil {
		return *x.Nonce
	}
	return Default_Procedure_Nonce
}
type SequentialProcedureData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Executed *bool `protobuf:"varint,1,req,name=executed" json:"executed,omitempty"`
}
func (x *SequentialProcedureData) Reset() {
	*x = SequentialProcedureData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_Procedure_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *SequentialProcedureData) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*SequentialProcedureData) ProtoMessage() {}
func (x *SequentialProcedureData) ProtoReflect() protoreflect.Message {
	mi := &file_Procedure_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*SequentialProcedureData) Descriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{1}
}
func (x *SequentialProcedureData) GetExecuted() bool {
	if x != nil && x.Executed != nil {
		return *x.Executed
	}
	return false
}
type StateMachineProcedureData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	State []uint32 `protobuf:"varint,1,rep,name=state" json:"state,omitempty"`
}
func (x *StateMachineProcedureData) Reset() {
	*x = StateMachineProcedureData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_Procedure_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *StateMachineProcedureData) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*StateMachineProcedureData) ProtoMessage() {}
func (x *StateMachineProcedureData) ProtoReflect() protoreflect.Message {
	mi := &file_Procedure_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*StateMachineProcedureData) Descriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{2}
}
func (x *StateMachineProcedureData) GetState() []uint32 {
	if x != nil {
		return x.State
	}
	return nil
}
type ProcedureWALHeader struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Version   *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
	Type      *uint32 `protobuf:"varint,2,req,name=type" json:"type,omitempty"`
	LogId     *uint64 `protobuf:"varint,3,req,name=log_id,json=logId" json:"log_id,omitempty"`
	MinProcId *uint64 `protobuf:"varint,4,req,name=min_proc_id,json=minProcId" json:"min_proc_id,omitempty"`
}
func (x *ProcedureWALHeader) Reset() {
	*x = ProcedureWALHeader{}
	if protoimpl.UnsafeEnabled {
		mi := &file_Procedure_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *ProcedureWALHeader) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*ProcedureWALHeader) ProtoMessage() {}
func (x *ProcedureWALHeader) ProtoReflect() protoreflect.Message {
	mi := &file_Procedure_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}
func (*ProcedureWALHeader) Descriptor() ([]byte, []int) {
	return file_Procedure_proto_rawDescGZIP(), []int{3}
}
func (x *ProcedureWALHeader) GetVersion() uint32 {
	if x != nil && x.Version != nil {
		return *x.Version
	}
	return 0
}
func (x *ProcedureWALHeader) GetType() uint32 {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return 0
}
func (x *ProcedureWALHeader) GetLogId() uint64 {
	if x != nil && x.LogId != nil {
		return *x.LogId
	}
	return 0
}
func (x *ProcedureWALHeader) GetMinProcId() uint64 {
	if x != nil && x.MinProcId != nil {
		return *x.MinProcId
	}
	return 0
}
type ProcedureWALTrailer struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
	Version    *uint32 `protobuf:"varint,1,req,name=version" json:"version,omitempty"`
	TrackerPos *uint64 `protobuf:"varint,2,req,name=tracker_pos,json=trackerPos" json:"tracker_pos,omitempty"`
}
func (x *ProcedureWALTrailer) Reset() {
	*x = ProcedureWALTrailer{}
	if protoimpl.UnsafeEnabled {
		mi := &file_Procedure_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}
func (x *ProcedureWALTrailer) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func (*ProcedureWALTrailer) ProtoMessage() {}
func (x *ProcedureWALTrailer) ProtoReflect() protoreflect.Message {
	mi := &file_Procedure_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}