meta.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: meta.proto

package metapb

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// BMLoader bitmap loader type
type BMLoader int32

const (
	RawLoader        BMLoader = 0
	KVLoader         BMLoader = 1
	KVShardLoader    BMLoader = 2
	ClickhouseLoader BMLoader = 3
)

var BMLoader_name = map[int32]string{
	0: "RawLoader",
	1: "KVLoader",
	2: "KVShardLoader",
	3: "ClickhouseLoader",
}

var BMLoader_value = map[string]int32{
	"RawLoader":        0,
	"KVLoader":         1,
	"KVShardLoader":    2,
	"ClickhouseLoader": 3,
}

func (x BMLoader) String() string {
	return proto.EnumName(BMLoader_name, int32(x))
}

func (BMLoader) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{0}
}

// WorkerRunnerState runner state
type WorkerRunnerState int32

const (
	WRRunning WorkerRunnerState = 0
	WRStopped WorkerRunnerState = 1
)

var WorkerRunnerState_name = map[int32]string{
	0: "WRRunning",
	1: "WRStopped",
}

var WorkerRunnerState_value = map[string]int32{
	"WRRunning": 0,
	"WRStopped": 1,
}

func (x WorkerRunnerState) String() string {
	return proto.EnumName(WorkerRunnerState_name, int32(x))
}

func (WorkerRunnerState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{1}
}

// WorkflowInstanceState workflow instance state
type WorkflowInstanceState int32

const (
	Starting WorkflowInstanceState = 0
	Running  WorkflowInstanceState = 1
	Stopping WorkflowInstanceState = 2
	Stopped  WorkflowInstanceState = 3
)

var WorkflowInstanceState_name = map[int32]string{
	0: "Starting",
	1: "Running",
	2: "Stopping",
	3: "Stopped",
}

var WorkflowInstanceState_value = map[string]int32{
	"Starting": 0,
	"Running":  1,
	"Stopping": 2,
	"Stopped":  3,
}

func (x WorkflowInstanceState) String() string {
	return proto.EnumName(WorkflowInstanceState_name, int32(x))
}

func (WorkflowInstanceState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{2}
}

// EventType tenant input event type
type EventType int32

const (
	UserType           EventType = 0
	UpdateCrowdType    EventType = 1
	UpdateWorkflowType EventType = 2
)

var EventType_name = map[int32]string{
	0: "UserType",
	1: "UpdateCrowdType",
	2: "UpdateWorkflowType",
}

var EventType_value = map[string]int32{
	"UserType":           0,
	"UpdateCrowdType":    1,
	"UpdateWorkflowType": 2,
}

func (x EventType) String() string {
	return proto.EnumName(EventType_name, int32(x))
}

func (EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{3}
}

// Group shard group
type Group int32

const (
	DefaultGroup      Group = 0
	TenantInputGroup  Group = 1
	TenantOutputGroup Group = 2
	TenantRunnerGroup Group = 3
)

var Group_name = map[int32]string{
	0: "DefaultGroup",
	1: "TenantInputGroup",
	2: "TenantOutputGroup",
	3: "TenantRunnerGroup",
}

var Group_value = map[string]int32{
	"DefaultGroup":      0,
	"TenantInputGroup":  1,
	"TenantOutputGroup": 2,
	"TenantRunnerGroup": 3,
}

func (x Group) String() string {
	return proto.EnumName(Group_name, int32(x))
}

func (Group) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{4}
}

// ExectuionType is is the type of a execution operation
type ExectuionType int32

const (
	// Direct is an executable operation.
	Direct ExectuionType = 0
	// Timer is an timer executable.
	Timer ExectuionType = 1
	// Branch contains several of the operations that will be performed if certain conditions are met.
	Branch ExectuionType = 2
	// Parallel contains multiple sets of operations that can be executed concurrently.
	Parallel ExectuionType = 3
)

var ExectuionType_name = map[int32]string{
	0: "Direct",
	1: "Timer",
	2: "Branch",
	3: "Parallel",
}

var ExectuionType_value = map[string]int32{
	"Direct":   0,
	"Timer":    1,
	"Branch":   2,
	"Parallel": 3,
}

func (x ExectuionType) String() string {
	return proto.EnumName(ExectuionType_name, int32(x))
}

func (ExectuionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{5}
}

// ExprResultType expr execute type
type ExprResultType int32

const (
	BoolResult ExprResultType = 0
	BMResult   ExprResultType = 1
)

var ExprResultType_name = map[int32]string{
	0: "BoolResult",
	1: "BMResult",
}

var ExprResultType_value = map[string]int32{
	"BoolResult": 0,
	"BMResult":   1,
}

func (x ExprResultType) String() string {
	return proto.EnumName(ExprResultType_name, int32(x))
}

func (ExprResultType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{6}
}

// TenantQueue queue metadata
type TenantQueue struct {
	Partitions      uint32 `protobuf:"varint,1,opt,name=partitions,proto3" json:"partitions,omitempty"`
	ConsumerTimeout int64  `protobuf:"varint,2,opt,name=consumerTimeout,proto3" json:"consumerTimeout,omitempty"`
	MaxAlive        int64  `protobuf:"varint,3,opt,name=maxAlive,proto3" json:"maxAlive,omitempty"`
	CleanBatch      uint64 `protobuf:"varint,4,opt,name=cleanBatch,proto3" json:"cleanBatch,omitempty"`
}

func (m *TenantQueue) Reset()         { *m = TenantQueue{} }
func (m *TenantQueue) String() string { return proto.CompactTextString(m) }
func (*TenantQueue) ProtoMessage()    {}
func (*TenantQueue) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{0}
}
func (m *TenantQueue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TenantQueue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TenantQueue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TenantQueue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TenantQueue.Merge(m, src)
}
func (m *TenantQueue) XXX_Size() int {
	return m.Size()
}
func (m *TenantQueue) XXX_DiscardUnknown() {
	xxx_messageInfo_TenantQueue.DiscardUnknown(m)
}

var xxx_messageInfo_TenantQueue proto.InternalMessageInfo

func (m *TenantQueue) GetPartitions() uint32 {
	if m != nil {
		return m.Partitions
	}
	return 0
}

func (m *TenantQueue) GetConsumerTimeout() int64 {
	if m != nil {
		return m.ConsumerTimeout
	}
	return 0
}

func (m *TenantQueue) GetMaxAlive() int64 {
	if m != nil {
		return m.MaxAlive
	}
	return 0
}

func (m *TenantQueue) GetCleanBatch() uint64 {
	if m != nil {
		return m.CleanBatch
	}
	return 0
}

// Tenant tenant metadata
type Tenant struct {
	ID           uint64      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Input        TenantQueue `protobuf:"bytes,2,opt,name=input,proto3" json:"input"`
	Output       TenantQueue `protobuf:"bytes,3,opt,name=output,proto3" json:"output"`
	Runners      uint64      `protobuf:"varint,4,opt,name=runners,proto3" json:"runners,omitempty"`
	InputsState  []bool      `protobuf:"varint,5,rep,packed,name=inputsState,proto3" json:"inputsState,omitempty"`
	OutputsState []bool      `protobuf:"varint,6,rep,packed,name=outputsState,proto3" json:"outputsState,omitempty"`
	RunnersState []bool      `protobuf:"varint,7,rep,packed,name=runnersState,proto3" json:"runnersState,omitempty"`
}

func (m *Tenant) Reset()         { *m = Tenant{} }
func (m *Tenant) String() string { return proto.CompactTextString(m) }
func (*Tenant) ProtoMessage()    {}
func (*Tenant) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{1}
}
func (m *Tenant) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Tenant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Tenant.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Tenant) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tenant.Merge(m, src)
}
func (m *Tenant) XXX_Size() int {
	return m.Size()
}
func (m *Tenant) XXX_DiscardUnknown() {
	xxx_messageInfo_Tenant.DiscardUnknown(m)
}

var xxx_messageInfo_Tenant proto.InternalMessageInfo

func (m *Tenant) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Tenant) GetInput() TenantQueue {
	if m != nil {
		return m.Input
	}
	return TenantQueue{}
}

func (m *Tenant) GetOutput() TenantQueue {
	if m != nil {
		return m.Output
	}
	return TenantQueue{}
}

func (m *Tenant) GetRunners() uint64 {
	if m != nil {
		return m.Runners
	}
	return 0
}

func (m *Tenant) GetInputsState() []bool {
	if m != nil {
		return m.InputsState
	}
	return nil
}

func (m *Tenant) GetOutputsState() []bool {
	if m != nil {
		return m.OutputsState
	}
	return nil
}

func (m *Tenant) GetRunnersState() []bool {
	if m != nil {
		return m.RunnersState
	}
	return nil
}

// WorkerRunner worker runner
type WorkerRunner struct {
	ID         uint64            `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Index      uint64            `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	State      WorkerRunnerState `protobuf:"varint,3,opt,name=state,proto3,enum=metapb.WorkerRunnerState" json:"state,omitempty"`
	Workers    []WorkflowWorker  `protobuf:"bytes,4,rep,name=workers,proto3" json:"workers"`
	TotalCrowd uint64            `protobuf:"varint,5,opt,name=totalCrowd,proto3" json:"totalCrowd,omitempty"`
}

func (m *WorkerRunner) Reset()         { *m = WorkerRunner{} }
func (m *WorkerRunner) String() string { return proto.CompactTextString(m) }
func (*WorkerRunner) ProtoMessage()    {}
func (*WorkerRunner) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{2}
}
func (m *WorkerRunner) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkerRunner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WorkerRunner.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WorkerRunner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkerRunner.Merge(m, src)
}
func (m *WorkerRunner) XXX_Size() int {
	return m.Size()
}
func (m *WorkerRunner) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkerRunner.DiscardUnknown(m)
}

var xxx_messageInfo_WorkerRunner proto.InternalMessageInfo

func (m *WorkerRunner) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *WorkerRunner) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *WorkerRunner) GetState() WorkerRunnerState {
	if m != nil {
		return m.State
	}
	return WRRunning
}

func (m *WorkerRunner) GetWorkers() []WorkflowWorker {
	if m != nil {
		return m.Workers
	}
	return nil
}

func (m *WorkerRunner) GetTotalCrowd() uint64 {
	if m != nil {
		return m.TotalCrowd
	}
	return 0
}

type WorkflowWorker struct {
	WorkflowID uint64 `protobuf:"varint,1,opt,name=workflowID,proto3" json:"workflowID,omitempty"`
	InstanceID uint64 `protobuf:"varint,2,opt,name=instanceID,proto3" json:"instanceID,omitempty"`
	Index      uint32 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *WorkflowWorker) Reset()         { *m = WorkflowWorker{} }
func (m *WorkflowWorker) String() string { return proto.CompactTextString(m) }
func (*WorkflowWorker) ProtoMessage()    {}
func (*WorkflowWorker) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{3}
}
func (m *WorkflowWorker) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkflowWorker) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WorkflowWorker.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WorkflowWorker) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowWorker.Merge(m, src)
}
func (m *WorkflowWorker) XXX_Size() int {
	return m.Size()
}
func (m *WorkflowWorker) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowWorker.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowWorker proto.InternalMessageInfo

func (m *WorkflowWorker) GetWorkflowID() uint64 {
	if m != nil {
		return m.WorkflowID
	}
	return 0
}

func (m *WorkflowWorker) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *WorkflowWorker) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

// ShardBitmapPutMeta shard bitmap put meta
type ShardBitmapPutMeta struct {
	Key           []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	TTL           uint32 `protobuf:"varint,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
	BytesPerShard uint32 `protobuf:"varint,3,opt,name=bytesPerShard,proto3" json:"bytesPerShard,omitempty"`
}

func (m *ShardBitmapPutMeta) Reset()         { *m = ShardBitmapPutMeta{} }
func (m *ShardBitmapPutMeta) String() string { return proto.CompactTextString(m) }
func (*ShardBitmapPutMeta) ProtoMessage()    {}
func (*ShardBitmapPutMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{4}
}
func (m *ShardBitmapPutMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardBitmapPutMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShardBitmapPutMeta.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ShardBitmapPutMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardBitmapPutMeta.Merge(m, src)
}
func (m *ShardBitmapPutMeta) XXX_Size() int {
	return m.Size()
}
func (m *ShardBitmapPutMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardBitmapPutMeta.DiscardUnknown(m)
}

var xxx_messageInfo_ShardBitmapPutMeta proto.InternalMessageInfo

func (m *ShardBitmapPutMeta) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ShardBitmapPutMeta) GetTTL() uint32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

func (m *ShardBitmapPutMeta) GetBytesPerShard() uint32 {
	if m != nil {
		return m.BytesPerShard
	}
	return 0
}

// ShardBitmapLoadMeta shard bitmap load meta
type ShardBitmapLoadMeta struct {
	Key    []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Total  uint64 `protobuf:"varint,2,opt,name=Total,proto3" json:"Total,omitempty"`
	Shards uint32 `protobuf:"varint,3,opt,name=shards,proto3" json:"shards,omitempty"`
}

func (m *ShardBitmapLoadMeta) Reset()         { *m = ShardBitmapLoadMeta{} }
func (m *ShardBitmapLoadMeta) String() string { return proto.CompactTextString(m) }
func (*ShardBitmapLoadMeta) ProtoMessage()    {}
func (*ShardBitmapLoadMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{5}
}
func (m *ShardBitmapLoadMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardBitmapLoadMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShardBitmapLoadMeta.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ShardBitmapLoadMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardBitmapLoadMeta.Merge(m, src)
}
func (m *ShardBitmapLoadMeta) XXX_Size() int {
	return m.Size()
}
func (m *ShardBitmapLoadMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardBitmapLoadMeta.DiscardUnknown(m)
}

var xxx_messageInfo_ShardBitmapLoadMeta proto.InternalMessageInfo

func (m *ShardBitmapLoadMeta) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ShardBitmapLoadMeta) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *ShardBitmapLoadMeta) GetShards() uint32 {
	if m != nil {
		return m.Shards
	}
	return 0
}

// IDValue is a id value
type IDValue struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Type  string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
}

func (m *IDValue) Reset()         { *m = IDValue{} }
func (m *IDValue) String() string { return proto.CompactTextString(m) }
func (*IDValue) ProtoMessage()    {}
func (*IDValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{6}
}
func (m *IDValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IDValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IDValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IDValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IDValue.Merge(m, src)
}
func (m *IDValue) XXX_Size() int {
	return m.Size()
}
func (m *IDValue) XXX_DiscardUnknown() {
	xxx_messageInfo_IDValue.DiscardUnknown(m)
}

var xxx_messageInfo_IDValue proto.InternalMessageInfo

func (m *IDValue) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *IDValue) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

// IDSet id set
type IDSet struct {
	Values []IDValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values"`
}

func (m *IDSet) Reset()         { *m = IDSet{} }
func (m *IDSet) String() string { return proto.CompactTextString(m) }
func (*IDSet) ProtoMessage()    {}
func (*IDSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{7}
}
func (m *IDSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IDSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IDSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IDSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IDSet.Merge(m, src)
}
func (m *IDSet) XXX_Size() int {
	return m.Size()
}
func (m *IDSet) XXX_DiscardUnknown() {
	xxx_messageInfo_IDSet.DiscardUnknown(m)
}

var xxx_messageInfo_IDSet proto.InternalMessageInfo

func (m *IDSet) GetValues() []IDValue {
	if m != nil {
		return m.Values
	}
	return nil
}

// Event tenant event
type Event struct {
	Type           EventType            `protobuf:"varint,1,opt,name=type,proto3,enum=metapb.EventType" json:"type,omitempty"`
	User           *UserEvent           `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	UpdateCrowd    *UpdateCrowdEvent    `protobuf:"bytes,3,opt,name=updateCrowd,proto3" json:"updateCrowd,omitempty"`
	UpdateWorkflow *UpdateWorkflowEvent `protobuf:"bytes,4,opt,name=updateWorkflow,proto3" json:"updateWorkflow,omitempty"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{8}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Event.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return m.Size()
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetType() EventType {
	if m != nil {
		return m.Type
	}
	return UserType
}

func (m *Event) GetUser() *UserEvent {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *Event) GetUpdateCrowd() *UpdateCrowdEvent {
	if m != nil {
		return m.UpdateCrowd
	}
	return nil
}

func (m *Event) GetUpdateWorkflow() *UpdateWorkflowEvent {
	if m != nil {
		return m.UpdateWorkflow
	}
	return nil
}

// UpdateCrowdEvent update crowd event
type UpdateCrowdEvent struct {
	WorkflowID uint64 `protobuf:"varint,1,opt,name=workflowID,proto3" json:"workflowID,omitempty"`
	Index      uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Crowd      []byte `protobuf:"bytes,3,opt,name=crowd,proto3" json:"crowd,omitempty"`
}

func (m *UpdateCrowdEvent) Reset()         { *m = UpdateCrowdEvent{} }
func (m *UpdateCrowdEvent) String() string { return proto.CompactTextString(m) }
func (*UpdateCrowdEvent) ProtoMessage()    {}
func (*UpdateCrowdEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{9}
}
func (m *UpdateCrowdEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateCrowdEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateCrowdEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateCrowdEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateCrowdEvent.Merge(m, src)
}
func (m *UpdateCrowdEvent) XXX_Size() int {
	return m.Size()
}
func (m *UpdateCrowdEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateCrowdEvent.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateCrowdEvent proto.InternalMessageInfo

func (m *UpdateCrowdEvent) GetWorkflowID() uint64 {
	if m != nil {
		return m.WorkflowID
	}
	return 0
}

func (m *UpdateCrowdEvent) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *UpdateCrowdEvent) GetCrowd() []byte {
	if m != nil {
		return m.Crowd
	}
	return nil
}

// UpdateWorkflowEvent update crowd event
type UpdateWorkflowEvent struct {
	Workflow Workflow `protobuf:"bytes,1,opt,name=workflow,proto3" json:"workflow"`
}

func (m *UpdateWorkflowEvent) Reset()         { *m = UpdateWorkflowEvent{} }
func (m *UpdateWorkflowEvent) String() string { return proto.CompactTextString(m) }
func (*UpdateWorkflowEvent) ProtoMessage()    {}
func (*UpdateWorkflowEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{10}
}
func (m *UpdateWorkflowEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateWorkflowEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateWorkflowEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateWorkflowEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateWorkflowEvent.Merge(m, src)
}
func (m *UpdateWorkflowEvent) XXX_Size() int {
	return m.Size()
}
func (m *UpdateWorkflowEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateWorkflowEvent.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateWorkflowEvent proto.InternalMessageInfo

func (m *UpdateWorkflowEvent) GetWorkflow() Workflow {
	if m != nil {
		return m.Workflow
	}
	return Workflow{}
}

// UserEvent is process definition
type UserEvent struct {
	UserID   uint32 `protobuf:"varint,1,opt,name=userID,proto3" json:"userID,omitempty"`
	TenantID uint64 `protobuf:"varint,2,opt,name=tenantID,proto3" json:"tenantID,omitempty"`
	Data     []KV   `protobuf:"bytes,3,rep,name=data,proto3" json:"data"`
}

func (m *UserEvent) Reset()         { *m = UserEvent{} }
func (m *UserEvent) String() string { return proto.CompactTextString(m) }
func (*UserEvent) ProtoMessage()    {}
func (*UserEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{11}
}
func (m *UserEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UserEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UserEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UserEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UserEvent.Merge(m, src)
}
func (m *UserEvent) XXX_Size() int {
	return m.Size()
}
func (m *UserEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_UserEvent.DiscardUnknown(m)
}

var xxx_messageInfo_UserEvent proto.InternalMessageInfo

func (m *UserEvent) GetUserID() uint32 {
	if m != nil {
		return m.UserID
	}
	return 0
}

func (m *UserEvent) GetTenantID() uint64 {
	if m != nil {
		return m.TenantID
	}
	return 0
}

func (m *UserEvent) GetData() []KV {
	if m != nil {
		return m.Data
	}
	return nil
}

// KV custom KV data
type KV struct {
	Key   []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *KV) Reset()         { *m = KV{} }
func (m *KV) String() string { return proto.CompactTextString(m) }
func (*KV) ProtoMessage()    {}
func (*KV) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{12}
}
func (m *KV) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KV) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KV.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KV) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KV.Merge(m, src)
}
func (m *KV) XXX_Size() int {
	return m.Size()
}
func (m *KV) XXX_DiscardUnknown() {
	xxx_messageInfo_KV.DiscardUnknown(m)
}

var xxx_messageInfo_KV proto.InternalMessageInfo

func (m *KV) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *KV) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

// Notify notify message
type Notify struct {
	UserID         uint32 `protobuf:"varint,1,opt,name=userID,proto3" json:"userID,omitempty"`
	Crowd          []byte `protobuf:"bytes,2,opt,name=crowd,proto3" json:"crowd,omitempty"`
	TenantID       uint64 `protobuf:"varint,3,opt,name=tenantID,proto3" json:"tenantID,omitempty"`
	WorkflowID     uint64 `protobuf:"varint,4,opt,name=workflowID,proto3" json:"workflowID,omitempty"`
	InstanceID     uint64 `protobuf:"varint,5,opt,name=instanceID,proto3" json:"instanceID,omitempty"`
	FromStep       string `protobuf:"bytes,6,opt,name=fromStep,proto3" json:"fromStep,omitempty"`
	FromAction     string `protobuf:"bytes,7,opt,name=fromAction,proto3" json:"fromAction,omitempty"`
	ToStep         string `protobuf:"bytes,8,opt,name=toStep,proto3" json:"toStep,omitempty"`
	ToAction       string `protobuf:"bytes,9,opt,name=toAction,proto3" json:"toAction,omitempty"`
	ToStepCycleTTL int32  `protobuf:"varint,10,opt,name=toStepCycleTTL,proto3" json:"toStepCycleTTL,omitempty"`
}

func (m *Notify) Reset()         { *m = Notify{} }
func (m *Notify) String() string { return proto.CompactTextString(m) }
func (*Notify) ProtoMessage()    {}
func (*Notify) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{13}
}
func (m *Notify) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Notify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Notify.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Notify) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Notify.Merge(m, src)
}
func (m *Notify) XXX_Size() int {
	return m.Size()
}
func (m *Notify) XXX_DiscardUnknown() {
	xxx_messageInfo_Notify.DiscardUnknown(m)
}

var xxx_messageInfo_Notify proto.InternalMessageInfo

func (m *Notify) GetUserID() uint32 {
	if m != nil {
		return m.UserID
	}
	return 0
}

func (m *Notify) GetCrowd() []byte {
	if m != nil {
		return m.Crowd
	}
	return nil
}

func (m *Notify) GetTenantID() uint64 {
	if m != nil {
		return m.TenantID
	}
	return 0
}

func (m *Notify) GetWorkflowID() uint64 {
	if m != nil {
		return m.WorkflowID
	}
	return 0
}

func (m *Notify) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *Notify) GetFromStep() string {
	if m != nil {
		return m.FromStep
	}
	return ""
}

func (m *Notify) GetFromAction() string {
	if m != nil {
		return m.FromAction
	}
	return ""
}

func (m *Notify) GetToStep() string {
	if m != nil {
		return m.ToStep
	}
	return ""
}

func (m *Notify) GetToAction() string {
	if m != nil {
		return m.ToAction
	}
	return ""
}

func (m *Notify) GetToStepCycleTTL() int32 {
	if m != nil {
		return m.ToStepCycleTTL
	}
	return 0
}

// Workflow is process definition
type Workflow struct {
	ID       uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	TenantID uint64 `protobuf:"varint,2,opt,name=tenantID,proto3" json:"tenantID,omitempty"`
	Name     string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Steps    []Step `protobuf:"bytes,4,rep,name=steps,proto3" json:"steps"`
	StopAt   int64  `protobuf:"varint,5,opt,name=stopAt,proto3" json:"stopAt,omitempty"`
}

func (m *Workflow) Reset()         { *m = Workflow{} }
func (m *Workflow) String() string { return proto.CompactTextString(m) }
func (*Workflow) ProtoMessage()    {}
func (*Workflow) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{14}
}
func (m *Workflow) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Workflow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Workflow.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Workflow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Workflow.Merge(m, src)
}
func (m *Workflow) XXX_Size() int {
	return m.Size()
}
func (m *Workflow) XXX_DiscardUnknown() {
	xxx_messageInfo_Workflow.DiscardUnknown(m)
}

var xxx_messageInfo_Workflow proto.InternalMessageInfo

func (m *Workflow) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Workflow) GetTenantID() uint64 {
	if m != nil {
		return m.TenantID
	}
	return 0
}

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

func (m *Workflow) GetSteps() []Step {
	if m != nil {
		return m.Steps
	}
	return nil
}

func (m *Workflow) GetStopAt() int64 {
	if m != nil {
		return m.StopAt
	}
	return 0
}

// WorkflowInstance workflow instance
type WorkflowInstance struct {
	Snapshot   Workflow              `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot"`
	InstanceID uint64                `protobuf:"varint,2,opt,name=instanceID,proto3" json:"instanceID,omitempty"`
	LoaderMeta []byte                `protobuf:"bytes,3,opt,name=loaderMeta,proto3" json:"loaderMeta,omitempty"`
	Loader     BMLoader              `protobuf:"varint,4,opt,name=loader,proto3,enum=metapb.BMLoader" json:"loader,omitempty"`
	TotalCrowd uint64                `protobuf:"varint,5,opt,name=totalCrowd,proto3" json:"totalCrowd,omitempty"`
	StartedAt  int64                 `protobuf:"varint,6,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
	StoppedAt  int64                 `protobuf:"varint,7,opt,name=stoppedAt,proto3" json:"stoppedAt,omitempty"`
	Version    uint64                `protobuf:"varint,8,opt,name=version,proto3" json:"version,omitempty"`
	State      WorkflowInstanceState `protobuf:"varint,9,opt,name=state,proto3,enum=metapb.WorkflowInstanceState" json:"state,omitempty"`
}

func (m *WorkflowInstance) Reset()         { *m = WorkflowInstance{} }
func (m *WorkflowInstance) String() string { return proto.CompactTextString(m) }
func (*WorkflowInstance) ProtoMessage()    {}
func (*WorkflowInstance) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{15}
}
func (m *WorkflowInstance) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkflowInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WorkflowInstance.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WorkflowInstance) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowInstance.Merge(m, src)
}
func (m *WorkflowInstance) XXX_Size() int {
	return m.Size()
}
func (m *WorkflowInstance) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowInstance.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowInstance proto.InternalMessageInfo

func (m *WorkflowInstance) GetSnapshot() Workflow {
	if m != nil {
		return m.Snapshot
	}
	return Workflow{}
}

func (m *WorkflowInstance) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *WorkflowInstance) GetLoaderMeta() []byte {
	if m != nil {
		return m.LoaderMeta
	}
	return nil
}

func (m *WorkflowInstance) GetLoader() BMLoader {
	if m != nil {
		return m.Loader
	}
	return RawLoader
}

func (m *WorkflowInstance) GetTotalCrowd() uint64 {
	if m != nil {
		return m.TotalCrowd
	}
	return 0
}

func (m *WorkflowInstance) GetStartedAt() int64 {
	if m != nil {
		return m.StartedAt
	}
	return 0
}

func (m *WorkflowInstance) GetStoppedAt() int64 {
	if m != nil {
		return m.StoppedAt
	}
	return 0
}

func (m *WorkflowInstance) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *WorkflowInstance) GetState() WorkflowInstanceState {
	if m != nil {
		return m.State
	}
	return Starting
}

// WorkflowInstanceSnapshot workflow instance snapshpot
type WorkflowInstanceSnapshot struct {
	Snapshot  WorkflowInstance `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot"`
	Timestamp int64            `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	States    []StepState      `protobuf:"bytes,3,rep,name=states,proto3" json:"states"`
}

func (m *WorkflowInstanceSnapshot) Reset()         { *m = WorkflowInstanceSnapshot{} }
func (m *WorkflowInstanceSnapshot) String() string { return proto.CompactTextString(m) }
func (*WorkflowInstanceSnapshot) ProtoMessage()    {}
func (*WorkflowInstanceSnapshot) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{16}
}
func (m *WorkflowInstanceSnapshot) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkflowInstanceSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WorkflowInstanceSnapshot.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WorkflowInstanceSnapshot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowInstanceSnapshot.Merge(m, src)
}
func (m *WorkflowInstanceSnapshot) XXX_Size() int {
	return m.Size()
}
func (m *WorkflowInstanceSnapshot) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowInstanceSnapshot.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowInstanceSnapshot proto.InternalMessageInfo

func (m *WorkflowInstanceSnapshot) GetSnapshot() WorkflowInstance {
	if m != nil {
		return m.Snapshot
	}
	return WorkflowInstance{}
}

func (m *WorkflowInstanceSnapshot) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *WorkflowInstanceSnapshot) GetStates() []StepState {
	if m != nil {
		return m.States
	}
	return nil
}

// WorkflowInstanceWorkerState workflow instance state. instance : instanceState = 1 : N
type WorkflowInstanceWorkerState struct {
	TenantID   uint64      `protobuf:"varint,1,opt,name=tenantID,proto3" json:"tenantID,omitempty"`
	WorkflowID uint64      `protobuf:"varint,2,opt,name=workflowID,proto3" json:"workflowID,omitempty"`
	InstanceID uint64      `protobuf:"varint,3,opt,name=instanceID,proto3" json:"instanceID,omitempty"`
	Index      uint32      `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
	States     []StepState `protobuf:"bytes,5,rep,name=states,proto3" json:"states"`
	Version    uint64      `protobuf:"varint,6,opt,name=version,proto3" json:"version,omitempty"`
	StopAt     int64       `protobuf:"varint,7,opt,name=stopAt,proto3" json:"stopAt,omitempty"`
	Runner     uint64      `protobuf:"varint,8,opt,name=runner,proto3" json:"runner,omitempty"`
}

func (m *WorkflowInstanceWorkerState) Reset()         { *m = WorkflowInstanceWorkerState{} }
func (m *WorkflowInstanceWorkerState) String() string { return proto.CompactTextString(m) }
func (*WorkflowInstanceWorkerState) ProtoMessage()    {}
func (*WorkflowInstanceWorkerState) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{17}
}
func (m *WorkflowInstanceWorkerState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkflowInstanceWorkerState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WorkflowInstanceWorkerState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WorkflowInstanceWorkerState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowInstanceWorkerState.Merge(m, src)
}
func (m *WorkflowInstanceWorkerState) XXX_Size() int {
	return m.Size()
}
func (m *WorkflowInstanceWorkerState) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowInstanceWorkerState.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowInstanceWorkerState proto.InternalMessageInfo

func (m *WorkflowInstanceWorkerState) GetTenantID() uint64 {
	if m != nil {
		return m.TenantID
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetWorkflowID() uint64 {
	if m != nil {
		return m.WorkflowID
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetStates() []StepState {
	if m != nil {
		return m.States
	}
	return nil
}

func (m *WorkflowInstanceWorkerState) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetStopAt() int64 {
	if m != nil {
		return m.StopAt
	}
	return 0
}

func (m *WorkflowInstanceWorkerState) GetRunner() uint64 {
	if m != nil {
		return m.Runner
	}
	return 0
}

// CountState step count state
type CountState struct {
	Step  string `protobuf:"bytes,1,opt,name=step,proto3" json:"step,omitempty"`
	Count uint64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
}

func (m *CountState) Reset()         { *m = CountState{} }
func (m *CountState) String() string { return proto.CompactTextString(m) }
func (*CountState) ProtoMessage()    {}
func (*CountState) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{18}
}
func (m *CountState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CountState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CountState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CountState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountState.Merge(m, src)
}
func (m *CountState) XXX_Size() int {
	return m.Size()
}
func (m *CountState) XXX_DiscardUnknown() {
	xxx_messageInfo_CountState.DiscardUnknown(m)
}

var xxx_messageInfo_CountState proto.InternalMessageInfo

func (m *CountState) GetStep() string {
	if m != nil {
		return m.Step
	}
	return ""
}

func (m *CountState) GetCount() uint64 {
	if m != nil {
		return m.Count
	}
	return 0
}

// InstanceCountState active instance count state
type InstanceCountState struct {
	Snapshot Workflow     `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot"`
	States   []CountState `protobuf:"bytes,2,rep,name=states,proto3" json:"states"`
	Total    uint64       `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"`
}

func (m *InstanceCountState) Reset()         { *m = InstanceCountState{} }
func (m *InstanceCountState) String() string { return proto.CompactTextString(m) }
func (*InstanceCountState) ProtoMessage()    {}
func (*InstanceCountState) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{19}
}
func (m *InstanceCountState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InstanceCountState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InstanceCountState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InstanceCountState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InstanceCountState.Merge(m, src)
}
func (m *InstanceCountState) XXX_Size() int {
	return m.Size()
}
func (m *InstanceCountState) XXX_DiscardUnknown() {
	xxx_messageInfo_InstanceCountState.DiscardUnknown(m)
}

var xxx_messageInfo_InstanceCountState proto.InternalMessageInfo

func (m *InstanceCountState) GetSnapshot() Workflow {
	if m != nil {
		return m.Snapshot
	}
	return Workflow{}
}

func (m *InstanceCountState) GetStates() []CountState {
	if m != nil {
		return m.States
	}
	return nil
}

func (m *InstanceCountState) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

// StepState workflow step state.
type StepState struct {
	Step       Step     `protobuf:"bytes,1,opt,name=step,proto3" json:"step"`
	TotalCrowd uint64   `protobuf:"varint,2,opt,name=totalCrowd,proto3" json:"totalCrowd,omitempty"`
	Loader     BMLoader `protobuf:"varint,3,opt,name=loader,proto3,enum=metapb.BMLoader" json:"loader,omitempty"`
	LoaderMeta []byte   `protobuf:"bytes,4,opt,name=loaderMeta,proto3" json:"loaderMeta,omitempty"`
}

func (m *StepState) Reset()         { *m = StepState{} }
func (m *StepState) String() string { return proto.CompactTextString(m) }
func (*StepState) ProtoMessage()    {}
func (*StepState) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{20}
}
func (m *StepState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StepState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StepState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StepState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StepState.Merge(m, src)
}
func (m *StepState) XXX_Size() int {
	return m.Size()
}
func (m *StepState) XXX_DiscardUnknown() {
	xxx_messageInfo_StepState.DiscardUnknown(m)
}

var xxx_messageInfo_StepState proto.InternalMessageInfo

func (m *StepState) GetStep() Step {
	if m != nil {
		return m.Step
	}
	return Step{}
}

func (m *StepState) GetTotalCrowd() uint64 {
	if m != nil {
		return m.TotalCrowd
	}
	return 0
}

func (m *StepState) GetLoader() BMLoader {
	if m != nil {
		return m.Loader
	}
	return RawLoader
}

func (m *StepState) GetLoaderMeta() []byte {
	if m != nil {
		return m.LoaderMeta
	}
	return nil
}

// Step is a step of the work flow
type Step struct {
	Name        string    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Execution   Execution `protobuf:"bytes,2,opt,name=execution,proto3" json:"execution"`
	EnterAction string    `protobuf:"bytes,3,opt,name=enterAction,proto3" json:"enterAction,omitempty"`
	LeaveAction string    `protobuf:"bytes,4,opt,name=leaveAction,proto3" json:"leaveAction,omitempty"`
	TTL         int32     `protobuf:"varint,5,opt,name=ttl,proto3" json:"ttl,omitempty"`
}

func (m *Step) Reset()         { *m = Step{} }
func (m *Step) String() string { return proto.CompactTextString(m) }
func (*Step) ProtoMessage()    {}
func (*Step) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{21}
}
func (m *Step) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Step) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Step.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Step) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Step.Merge(m, src)
}
func (m *Step) XXX_Size() int {
	return m.Size()
}
func (m *Step) XXX_DiscardUnknown() {
	xxx_messageInfo_Step.DiscardUnknown(m)
}

var xxx_messageInfo_Step proto.InternalMessageInfo

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

func (m *Step) GetExecution() Execution {
	if m != nil {
		return m.Execution
	}
	return Execution{}
}

func (m *Step) GetEnterAction() string {
	if m != nil {
		return m.EnterAction
	}
	return ""
}

func (m *Step) GetLeaveAction() string {
	if m != nil {
		return m.LeaveAction
	}
	return ""
}

func (m *Step) GetTTL() int32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

// Execution is node operation in a seqence of executions.
// A node may have the following roles:
// 1. DirectExecution
// 2. BranchExecution
// 3. ParallelExecution
type Execution struct {
	Type     ExectuionType        `protobuf:"varint,1,opt,name=type,proto3,enum=metapb.ExectuionType" json:"type,omitempty"`
	Timer    *TimerExecution      `protobuf:"bytes,2,opt,name=timer,proto3" json:"timer,omitempty"`
	Direct   *DirectExecution     `protobuf:"bytes,3,opt,name=direct,proto3" json:"direct,omitempty"`
	Branches []ConditionExecution `protobuf:"bytes,4,rep,name=branches,proto3" json:"branches"`
	Parallel ParallelExecution    `protobuf:"bytes,5,opt,name=parallel,proto3" json:"parallel"`
}

func (m *Execution) Reset()         { *m = Execution{} }
func (m *Execution) String() string { return proto.CompactTextString(m) }
func (*Execution) ProtoMessage()    {}
func (*Execution) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{22}
}
func (m *Execution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Execution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Execution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Execution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Execution.Merge(m, src)
}
func (m *Execution) XXX_Size() int {
	return m.Size()
}
func (m *Execution) XXX_DiscardUnknown() {
	xxx_messageInfo_Execution.DiscardUnknown(m)
}

var xxx_messageInfo_Execution proto.InternalMessageInfo

func (m *Execution) GetType() ExectuionType {
	if m != nil {
		return m.Type
	}
	return Direct
}

func (m *Execution) GetTimer() *TimerExecution {
	if m != nil {
		return m.Timer
	}
	return nil
}

func (m *Execution) GetDirect() *DirectExecution {
	if m != nil {
		return m.Direct
	}
	return nil
}

func (m *Execution) GetBranches() []ConditionExecution {
	if m != nil {
		return m.Branches
	}
	return nil
}

func (m *Execution) GetParallel() ParallelExecution {
	if m != nil {
		return m.Parallel
	}
	return ParallelExecution{}
}

// TimerExecution is a timer performable operation
type TimerExecution struct {
	Condition           *Expr  `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"`
	Cron                string `protobuf:"bytes,2,opt,name=cron,proto3" json:"cron,omitempty"`
	NextStep            string `protobuf:"bytes,3,opt,name=nextStep,proto3" json:"nextStep,omitempty"`
	UseStepCrowdToDrive bool   `protobuf:"varint,4,opt,name=useStepCrowdToDrive,proto3" json:"useStepCrowdToDrive,omitempty"`
}

func (m *TimerExecution) Reset()         { *m = TimerExecution{} }
func (m *TimerExecution) String() string { return proto.CompactTextString(m) }
func (*TimerExecution) ProtoMessage()    {}
func (*TimerExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{23}
}
func (m *TimerExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TimerExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TimerExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TimerExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TimerExecution.Merge(m, src)
}
func (m *TimerExecution) XXX_Size() int {
	return m.Size()
}
func (m *TimerExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_TimerExecution.DiscardUnknown(m)
}

var xxx_messageInfo_TimerExecution proto.InternalMessageInfo

func (m *TimerExecution) GetCondition() *Expr {
	if m != nil {
		return m.Condition
	}
	return nil
}

func (m *TimerExecution) GetCron() string {
	if m != nil {
		return m.Cron
	}
	return ""
}

func (m *TimerExecution) GetNextStep() string {
	if m != nil {
		return m.NextStep
	}
	return ""
}

func (m *TimerExecution) GetUseStepCrowdToDrive() bool {
	if m != nil {
		return m.UseStepCrowdToDrive
	}
	return false
}

// ParallelExecution is a parallel execution
type ParallelExecution struct {
	NextStep  string      `protobuf:"bytes,1,opt,name=nextStep,proto3" json:"nextStep,omitempty"`
	Parallels []Execution `protobuf:"bytes,2,rep,name=parallels,proto3" json:"parallels"`
}

func (m *ParallelExecution) Reset()         { *m = ParallelExecution{} }
func (m *ParallelExecution) String() string { return proto.CompactTextString(m) }
func (*ParallelExecution) ProtoMessage()    {}
func (*ParallelExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{24}
}
func (m *ParallelExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ParallelExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ParallelExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ParallelExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParallelExecution.Merge(m, src)
}
func (m *ParallelExecution) XXX_Size() int {
	return m.Size()
}
func (m *ParallelExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_ParallelExecution.DiscardUnknown(m)
}

var xxx_messageInfo_ParallelExecution proto.InternalMessageInfo

func (m *ParallelExecution) GetNextStep() string {
	if m != nil {
		return m.NextStep
	}
	return ""
}

func (m *ParallelExecution) GetParallels() []Execution {
	if m != nil {
		return m.Parallels
	}
	return nil
}

// DirectExecution is a directly performable operation
type DirectExecution struct {
	NextStep string `protobuf:"bytes,1,opt,name=nextStep,proto3" json:"nextStep,omitempty"`
}

func (m *DirectExecution) Reset()         { *m = DirectExecution{} }
func (m *DirectExecution) String() string { return proto.CompactTextString(m) }
func (*DirectExecution) ProtoMessage()    {}
func (*DirectExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{25}
}
func (m *DirectExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DirectExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DirectExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DirectExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DirectExecution.Merge(m, src)
}
func (m *DirectExecution) XXX_Size() int {
	return m.Size()
}
func (m *DirectExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_DirectExecution.DiscardUnknown(m)
}

var xxx_messageInfo_DirectExecution proto.InternalMessageInfo

func (m *DirectExecution) GetNextStep() string {
	if m != nil {
		return m.NextStep
	}
	return ""
}

// ConditionExecution is selecting multiple operations to satisfy the operation of the conditional operation
type ConditionExecution struct {
	Condition Expr       `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition"`
	Execution *Execution `protobuf:"bytes,2,opt,name=execution,proto3" json:"execution,omitempty"`
	NextStep  string     `protobuf:"bytes,3,opt,name=nextStep,proto3" json:"nextStep,omitempty"`
}

func (m *ConditionExecution) Reset()         { *m = ConditionExecution{} }
func (m *ConditionExecution) String() string { return proto.CompactTextString(m) }
func (*ConditionExecution) ProtoMessage()    {}
func (*ConditionExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{26}
}
func (m *ConditionExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConditionExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConditionExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConditionExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConditionExecution.Merge(m, src)
}
func (m *ConditionExecution) XXX_Size() int {
	return m.Size()
}
func (m *ConditionExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_ConditionExecution.DiscardUnknown(m)
}

var xxx_messageInfo_ConditionExecution proto.InternalMessageInfo

func (m *ConditionExecution) GetCondition() Expr {
	if m != nil {
		return m.Condition
	}
	return Expr{}
}

func (m *ConditionExecution) GetExecution() *Execution {
	if m != nil {
		return m.Execution
	}
	return nil
}

func (m *ConditionExecution) GetNextStep() string {
	if m != nil {
		return m.NextStep
	}
	return ""
}

// Expr expr
type Expr struct {
	Value []byte         `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Type  ExprResultType `protobuf:"varint,2,opt,name=type,proto3,enum=metapb.ExprResultType" json:"type,omitempty"`
}

func (m *Expr) Reset()         { *m = Expr{} }
func (m *Expr) String() string { return proto.CompactTextString(m) }
func (*Expr) ProtoMessage()    {}
func (*Expr) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{27}
}
func (m *Expr) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Expr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Expr.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Expr) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Expr.Merge(m, src)
}
func (m *Expr) XXX_Size() int {
	return m.Size()
}
func (m *Expr) XXX_DiscardUnknown() {
	xxx_messageInfo_Expr.DiscardUnknown(m)
}

var xxx_messageInfo_Expr proto.InternalMessageInfo

func (m *Expr) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Expr) GetType() ExprResultType {
	if m != nil {
		return m.Type
	}
	return BoolResult
}

// QueueState queue state
type QueueState struct {
	Partitions uint32     `protobuf:"varint,1,opt,name=partitions,proto3" json:"partitions,omitempty"`
	Consumers  uint32     `protobuf:"varint,2,opt,name=consumers,proto3" json:"consumers,omitempty"`
	States     []Partiton `protobuf:"bytes,3,rep,name=states,proto3" json:"states"`
	Timeout    int64      `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	MaxAlive   int64      `protobuf:"varint,5,opt,name=maxAlive,proto3" json:"maxAlive,omitempty"`
	CleanBatch uint64     `protobuf:"varint,6,opt,name=cleanBatch,proto3" json:"cleanBatch,omitempty"`
}

func (m *QueueState) Reset()         { *m = QueueState{} }
func (m *QueueState) String() string { return proto.CompactTextString(m) }
func (*QueueState) ProtoMessage()    {}
func (*QueueState) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{28}
}
func (m *QueueState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueueState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueueState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueueState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueueState.Merge(m, src)
}
func (m *QueueState) XXX_Size() int {
	return m.Size()
}
func (m *QueueState) XXX_DiscardUnknown() {
	xxx_messageInfo_QueueState.DiscardUnknown(m)
}

var xxx_messageInfo_QueueState proto.InternalMessageInfo

func (m *QueueState) GetPartitions() uint32 {
	if m != nil {
		return m.Partitions
	}
	return 0
}

func (m *QueueState) GetConsumers() uint32 {
	if m != nil {
		return m.Consumers
	}
	return 0
}

func (m *QueueState) GetStates() []Partiton {
	if m != nil {
		return m.States
	}
	return nil
}

func (m *QueueState) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *QueueState) GetMaxAlive() int64 {
	if m != nil {
		return m.MaxAlive
	}
	return 0
}

func (m *QueueState) GetCleanBatch() uint64 {
	if m != nil {
		return m.CleanBatch
	}
	return 0
}

// Partiton partition state
type Partiton struct {
	Consumer    uint32 `protobuf:"varint,1,opt,name=consumer,proto3" json:"consumer,omitempty"`
	Version     uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	LastFetchTS int64  `protobuf:"varint,3,opt,name=lastFetchTS,proto3" json:"lastFetchTS,omitempty"`
}

func (m *Partiton) Reset()         { *m = Partiton{} }
func (m *Partiton) String() string { return proto.CompactTextString(m) }
func (*Partiton) ProtoMessage()    {}
func (*Partiton) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{29}
}
func (m *Partiton) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Partiton) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Partiton.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Partiton) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Partiton.Merge(m, src)
}
func (m *Partiton) XXX_Size() int {
	return m.Size()
}
func (m *Partiton) XXX_DiscardUnknown() {
	xxx_messageInfo_Partiton.DiscardUnknown(m)
}

var xxx_messageInfo_Partiton proto.InternalMessageInfo

func (m *Partiton) GetConsumer() uint32 {
	if m != nil {
		return m.Consumer
	}
	return 0
}

func (m *Partiton) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Partiton) GetLastFetchTS() int64 {
	if m != nil {
		return m.LastFetchTS
	}
	return 0
}

// message CallbackAction
type CallbackAction struct {
	SetKV                 *SetKVAction                 `protobuf:"bytes,1,opt,name=setKV,proto3" json:"setKV,omitempty"`
	UpdateTenantInitState *TenantInitStateUpdateAction `protobuf:"bytes,2,opt,name=updateTenantInitState,proto3" json:"updateTenantInitState,omitempty"`
}

func (m *CallbackAction) Reset()         { *m = CallbackAction{} }
func (m *CallbackAction) String() string { return proto.CompactTextString(m) }
func (*CallbackAction) ProtoMessage()    {}
func (*CallbackAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{30}
}
func (m *CallbackAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CallbackAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CallbackAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CallbackAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CallbackAction.Merge(m, src)
}
func (m *CallbackAction) XXX_Size() int {
	return m.Size()
}
func (m *CallbackAction) XXX_DiscardUnknown() {
	xxx_messageInfo_CallbackAction.DiscardUnknown(m)
}

var xxx_messageInfo_CallbackAction proto.InternalMessageInfo

func (m *CallbackAction) GetSetKV() *SetKVAction {
	if m != nil {
		return m.SetKV
	}
	return nil
}

func (m *CallbackAction) GetUpdateTenantInitState() *TenantInitStateUpdateAction {
	if m != nil {
		return m.UpdateTenantInitState
	}
	return nil
}

// SetKVAction set kv action
type SetKVAction struct {
	KV    KV    `protobuf:"bytes,1,opt,name=kv,proto3" json:"kv"`
	Group Group `protobuf:"varint,2,opt,name=group,proto3,enum=metapb.Group" json:"group,omitempty"`
}

func (m *SetKVAction) Reset()         { *m = SetKVAction{} }
func (m *SetKVAction) String() string { return proto.CompactTextString(m) }
func (*SetKVAction) ProtoMessage()    {}
func (*SetKVAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{31}
}
func (m *SetKVAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetKVAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetKVAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetKVAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetKVAction.Merge(m, src)
}
func (m *SetKVAction) XXX_Size() int {
	return m.Size()
}
func (m *SetKVAction) XXX_DiscardUnknown() {
	xxx_messageInfo_SetKVAction.DiscardUnknown(m)
}

var xxx_messageInfo_SetKVAction proto.InternalMessageInfo

func (m *SetKVAction) GetKV() KV {
	if m != nil {
		return m.KV
	}
	return KV{}
}

func (m *SetKVAction) GetGroup() Group {
	if m != nil {
		return m.Group
	}
	return DefaultGroup
}

// TenantInitStateUpdateAction update tenant init state
type TenantInitStateUpdateAction struct {
	ID    uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Index int32  `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Group Group  `protobuf:"varint,3,opt,name=group,proto3,enum=metapb.Group" json:"group,omitempty"`
}

func (m *TenantInitStateUpdateAction) Reset()         { *m = TenantInitStateUpdateAction{} }
func (m *TenantInitStateUpdateAction) String() string { return proto.CompactTextString(m) }
func (*TenantInitStateUpdateAction) ProtoMessage()    {}
func (*TenantInitStateUpdateAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{32}
}
func (m *TenantInitStateUpdateAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TenantInitStateUpdateAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TenantInitStateUpdateAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TenantInitStateUpdateAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TenantInitStateUpdateAction.Merge(m, src)
}
func (m *TenantInitStateUpdateAction) XXX_Size() int {
	return m.Size()
}
func (m *TenantInitStateUpdateAction) XXX_DiscardUnknown() {
	xxx_messageInfo_TenantInitStateUpdateAction.DiscardUnknown(m)
}

var xxx_messageInfo_TenantInitStateUpdateAction proto.InternalMessageInfo

func (m *TenantInitStateUpdateAction) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *TenantInitStateUpdateAction) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *TenantInitStateUpdateAction) GetGroup() Group {
	if m != nil {
		return m.Group
	}
	return DefaultGroup
}

// TenantRunnerOffsets offsets
type TenantRunnerOffsets struct {
	Workers []string                     `protobuf:"bytes,1,rep,name=workers,proto3" json:"workers,omitempty"`
	Offsets []*TenantRunnerWorkerOffsets `protobuf:"bytes,2,rep,name=offsets,proto3" json:"offsets,omitempty"`
}

func (m *TenantRunnerOffsets) Reset()         { *m = TenantRunnerOffsets{} }
func (m *TenantRunnerOffsets) String() string { return proto.CompactTextString(m) }
func (*TenantRunnerOffsets) ProtoMessage()    {}
func (*TenantRunnerOffsets) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{33}
}
func (m *TenantRunnerOffsets) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TenantRunnerOffsets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TenantRunnerOffsets.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TenantRunnerOffsets) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TenantRunnerOffsets.Merge(m, src)
}
func (m *TenantRunnerOffsets) XXX_Size() int {
	return m.Size()
}
func (m *TenantRunnerOffsets) XXX_DiscardUnknown() {
	xxx_messageInfo_TenantRunnerOffsets.DiscardUnknown(m)
}

var xxx_messageInfo_TenantRunnerOffsets proto.InternalMessageInfo

func (m *TenantRunnerOffsets) GetWorkers() []string {
	if m != nil {
		return m.Workers
	}
	return nil
}

func (m *TenantRunnerOffsets) GetOffsets() []*TenantRunnerWorkerOffsets {
	if m != nil {
		return m.Offsets
	}
	return nil
}

// TenantRunnerWorkerOffsets offsets
type TenantRunnerWorkerOffsets struct {
	Offsets []uint64 `protobuf:"varint,1,rep,packed,name=offsets,proto3" json:"offsets,omitempty"`
}

func (m *TenantRunnerWorkerOffsets) Reset()         { *m = TenantRunnerWorkerOffsets{} }
func (m *TenantRunnerWorkerOffsets) String() string { return proto.CompactTextString(m) }
func (*TenantRunnerWorkerOffsets) ProtoMessage()    {}
func (*TenantRunnerWorkerOffsets) Descriptor() ([]byte, []int) {
	return fileDescriptor_3b5ea8fe65782bcc, []int{34}
}
func (m *TenantRunnerWorkerOffsets) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TenantRunnerWorkerOffsets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TenantRunnerWorkerOffsets.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TenantRunnerWorkerOffsets) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TenantRunnerWorkerOffsets.Merge(m, src)
}
func (m *TenantRunnerWorkerOffsets) XXX_Size() int {
	return m.Size()
}
func (m *TenantRunnerWorkerOffsets) XXX_DiscardUnknown() {
	xxx_messageInfo_TenantRunnerWorkerOffsets.DiscardUnknown(m)
}

var xxx_messageInfo_TenantRunnerWorkerOffsets proto.InternalMessageInfo

func (m *TenantRunnerWorkerOffsets) GetOffsets() []uint64 {
	if m != nil {
		return m.Offsets
	}
	return nil
}

func init() {
	proto.RegisterEnum("metapb.BMLoader", BMLoader_name, BMLoader_value)
	proto.RegisterEnum("metapb.WorkerRunnerState", WorkerRunnerState_name, WorkerRunnerState_value)
	proto.RegisterEnum("metapb.WorkflowInstanceState", WorkflowInstanceState_name, WorkflowInstanceState_value)
	proto.RegisterEnum("metapb.EventType", EventType_name, EventType_value)
	proto.RegisterEnum("metapb.Group", Group_name, Group_value)
	proto.RegisterEnum("metapb.ExectuionType", ExectuionType_name, ExectuionType_value)
	proto.RegisterEnum("metapb.ExprResultType", ExprResultType_name, ExprResultType_value)
	proto.RegisterType((*TenantQueue)(nil), "metapb.TenantQueue")
	proto.RegisterType((*Tenant)(nil), "metapb.Tenant")
	proto.RegisterType((*WorkerRunner)(nil), "metapb.WorkerRunner")
	proto.RegisterType((*WorkflowWorker)(nil), "metapb.WorkflowWorker")
	proto.RegisterType((*ShardBitmapPutMeta)(nil), "metapb.ShardBitmapPutMeta")
	proto.RegisterType((*ShardBitmapLoadMeta)(nil), "metapb.ShardBitmapLoadMeta")
	proto.RegisterType((*IDValue)(nil), "metapb.IDValue")
	proto.RegisterType((*IDSet)(nil), "metapb.IDSet")
	proto.RegisterType((*Event)(nil), "metapb.Event")
	proto.RegisterType((*UpdateCrowdEvent)(nil), "metapb.UpdateCrowdEvent")
	proto.RegisterType((*UpdateWorkflowEvent)(nil), "metapb.UpdateWorkflowEvent")
	proto.RegisterType((*UserEvent)(nil), "metapb.UserEvent")
	proto.RegisterType((*KV)(nil), "metapb.KV")
	proto.RegisterType((*Notify)(nil), "metapb.Notify")
	proto.RegisterType((*Workflow)(nil), "metapb.Workflow")
	proto.RegisterType((*WorkflowInstance)(nil), "metapb.WorkflowInstance")
	proto.RegisterType((*WorkflowInstanceSnapshot)(nil), "metapb.WorkflowInstanceSnapshot")
	proto.RegisterType((*WorkflowInstanceWorkerState)(nil), "metapb.WorkflowInstanceWorkerState")
	proto.RegisterType((*CountState)(nil), "metapb.CountState")
	proto.RegisterType((*InstanceCountState)(nil), "metapb.InstanceCountState")
	proto.RegisterType((*StepState)(nil), "metapb.StepState")
	proto.RegisterType((*Step)(nil), "metapb.Step")
	proto.RegisterType((*Execution)(nil), "metapb.Execution")
	proto.RegisterType((*TimerExecution)(nil), "metapb.TimerExecution")
	proto.RegisterType((*ParallelExecution)(nil), "metapb.ParallelExecution")
	proto.RegisterType((*DirectExecution)(nil), "metapb.DirectExecution")
	proto.RegisterType((*ConditionExecution)(nil), "metapb.ConditionExecution")
	proto.RegisterType((*Expr)(nil), "metapb.Expr")
	proto.RegisterType((*QueueState)(nil), "metapb.QueueState")
	proto.RegisterType((*Partiton)(nil), "metapb.Partiton")
	proto.RegisterType((*CallbackAction)(nil), "metapb.CallbackAction")
	proto.RegisterType((*SetKVAction)(nil), "metapb.SetKVAction")
	proto.RegisterType((*TenantInitStateUpdateAction)(nil), "metapb.TenantInitStateUpdateAction")
	proto.RegisterType((*TenantRunnerOffsets)(nil), "metapb.TenantRunnerOffsets")
	proto.RegisterType((*TenantRunnerWorkerOffsets)(nil), "metapb.TenantRunnerWorkerOffsets")
}

func init() { proto.RegisterFile("meta.proto", fileDescriptor_3b5ea8fe65782bcc) }

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

func (m *TenantQueue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TenantQueue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantQueue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CleanBatch != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.CleanBatch))
		i--
		dAtA[i] = 0x20
	}
	if m.MaxAlive != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.MaxAlive))
		i--
		dAtA[i] = 0x18
	}
	if m.ConsumerTimeout != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ConsumerTimeout))
		i--
		dAtA[i] = 0x10
	}
	if m.Partitions != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Partitions))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Tenant) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Tenant) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Tenant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RunnersState) > 0 {
		for iNdEx := len(m.RunnersState) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.RunnersState[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintMeta(dAtA, i, uint64(len(m.RunnersState)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.OutputsState) > 0 {
		for iNdEx := len(m.OutputsState) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.OutputsState[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintMeta(dAtA, i, uint64(len(m.OutputsState)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.InputsState) > 0 {
		for iNdEx := len(m.InputsState) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.InputsState[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintMeta(dAtA, i, uint64(len(m.InputsState)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Runners != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Runners))
		i--
		dAtA[i] = 0x20
	}
	{
		size, err := m.Output.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Input.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WorkerRunner) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkerRunner) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WorkerRunner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalCrowd != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TotalCrowd))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Workers) > 0 {
		for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Workers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.State != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WorkflowWorker) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkflowWorker) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WorkflowWorker) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if m.InstanceID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.InstanceID))
		i--
		dAtA[i] = 0x10
	}
	if m.WorkflowID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.WorkflowID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ShardBitmapPutMeta) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ShardBitmapPutMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShardBitmapPutMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BytesPerShard != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.BytesPerShard))
		i--
		dAtA[i] = 0x18
	}
	if m.TTL != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ShardBitmapLoadMeta) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ShardBitmapLoadMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ShardBitmapLoadMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Shards != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Shards))
		i--
		dAtA[i] = 0x18
	}
	if m.Total != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IDValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IDValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IDValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IDSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IDSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IDSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Event) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Event) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateWorkflow != nil {
		{
			size, err := m.UpdateWorkflow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UpdateCrowd != nil {
		{
			size, err := m.UpdateCrowd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.User != nil {
		{
			size, err := m.User.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UpdateCrowdEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateCrowdEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateCrowdEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Crowd) > 0 {
		i -= len(m.Crowd)
		copy(dAtA[i:], m.Crowd)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Crowd)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Index != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.WorkflowID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.WorkflowID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UpdateWorkflowEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateWorkflowEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateWorkflowEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Workflow.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *UserEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UserEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UserEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Data[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TenantID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TenantID))
		i--
		dAtA[i] = 0x10
	}
	if m.UserID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.UserID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *KV) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KV) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Notify) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Notify) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Notify) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ToStepCycleTTL != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ToStepCycleTTL))
		i--
		dAtA[i] = 0x50
	}
	if len(m.ToAction) > 0 {
		i -= len(m.ToAction)
		copy(dAtA[i:], m.ToAction)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.ToAction)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.ToStep) > 0 {
		i -= len(m.ToStep)
		copy(dAtA[i:], m.ToStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.ToStep)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.FromAction) > 0 {
		i -= len(m.FromAction)
		copy(dAtA[i:], m.FromAction)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.FromAction)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.FromStep) > 0 {
		i -= len(m.FromStep)
		copy(dAtA[i:], m.FromStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.FromStep)))
		i--
		dAtA[i] = 0x32
	}
	if m.InstanceID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.InstanceID))
		i--
		dAtA[i] = 0x28
	}
	if m.WorkflowID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.WorkflowID))
		i--
		dAtA[i] = 0x20
	}
	if m.TenantID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TenantID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Crowd) > 0 {
		i -= len(m.Crowd)
		copy(dAtA[i:], m.Crowd)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Crowd)))
		i--
		dAtA[i] = 0x12
	}
	if m.UserID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.UserID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Workflow) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Workflow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Workflow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StopAt != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.StopAt))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Steps) > 0 {
		for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Steps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TenantID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TenantID))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WorkflowInstance) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkflowInstance) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WorkflowInstance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x48
	}
	if m.Version != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x40
	}
	if m.StoppedAt != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.StoppedAt))
		i--
		dAtA[i] = 0x38
	}
	if m.StartedAt != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.StartedAt))
		i--
		dAtA[i] = 0x30
	}
	if m.TotalCrowd != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TotalCrowd))
		i--
		dAtA[i] = 0x28
	}
	if m.Loader != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Loader))
		i--
		dAtA[i] = 0x20
	}
	if len(m.LoaderMeta) > 0 {
		i -= len(m.LoaderMeta)
		copy(dAtA[i:], m.LoaderMeta)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.LoaderMeta)))
		i--
		dAtA[i] = 0x1a
	}
	if m.InstanceID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.InstanceID))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *WorkflowInstanceSnapshot) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkflowInstanceSnapshot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WorkflowInstanceSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.States) > 0 {
		for iNdEx := len(m.States) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.States[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Timestamp != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *WorkflowInstanceWorkerState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkflowInstanceWorkerState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WorkflowInstanceWorkerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Runner != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Runner))
		i--
		dAtA[i] = 0x40
	}
	if m.StopAt != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.StopAt))
		i--
		dAtA[i] = 0x38
	}
	if m.Version != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x30
	}
	if len(m.States) > 0 {
		for iNdEx := len(m.States) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.States[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Index != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x20
	}
	if m.InstanceID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.InstanceID))
		i--
		dAtA[i] = 0x18
	}
	if m.WorkflowID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.WorkflowID))
		i--
		dAtA[i] = 0x10
	}
	if m.TenantID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TenantID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CountState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CountState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CountState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Step) > 0 {
		i -= len(m.Step)
		copy(dAtA[i:], m.Step)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Step)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InstanceCountState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InstanceCountState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InstanceCountState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Total != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x18
	}
	if len(m.States) > 0 {
		for iNdEx := len(m.States) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.States[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *StepState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StepState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StepState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LoaderMeta) > 0 {
		i -= len(m.LoaderMeta)
		copy(dAtA[i:], m.LoaderMeta)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.LoaderMeta)))
		i--
		dAtA[i] = 0x22
	}
	if m.Loader != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Loader))
		i--
		dAtA[i] = 0x18
	}
	if m.TotalCrowd != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TotalCrowd))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Step.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Step) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Step) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Step) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TTL != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.TTL))
		i--
		dAtA[i] = 0x28
	}
	if len(m.LeaveAction) > 0 {
		i -= len(m.LeaveAction)
		copy(dAtA[i:], m.LeaveAction)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.LeaveAction)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.EnterAction) > 0 {
		i -= len(m.EnterAction)
		copy(dAtA[i:], m.EnterAction)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.EnterAction)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Execution.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Execution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Execution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Execution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Parallel.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Branches) > 0 {
		for iNdEx := len(m.Branches) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Branches[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Direct != nil {
		{
			size, err := m.Direct.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Timer != nil {
		{
			size, err := m.Timer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TimerExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TimerExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TimerExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UseStepCrowdToDrive {
		i--
		if m.UseStepCrowdToDrive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.NextStep) > 0 {
		i -= len(m.NextStep)
		copy(dAtA[i:], m.NextStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.NextStep)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Cron) > 0 {
		i -= len(m.Cron)
		copy(dAtA[i:], m.Cron)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Cron)))
		i--
		dAtA[i] = 0x12
	}
	if m.Condition != nil {
		{
			size, err := m.Condition.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ParallelExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ParallelExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParallelExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Parallels) > 0 {
		for iNdEx := len(m.Parallels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Parallels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NextStep) > 0 {
		i -= len(m.NextStep)
		copy(dAtA[i:], m.NextStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.NextStep)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DirectExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DirectExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DirectExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NextStep) > 0 {
		i -= len(m.NextStep)
		copy(dAtA[i:], m.NextStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.NextStep)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConditionExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConditionExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConditionExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NextStep) > 0 {
		i -= len(m.NextStep)
		copy(dAtA[i:], m.NextStep)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.NextStep)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Execution != nil {
		{
			size, err := m.Execution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Condition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Expr) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Expr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Expr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMeta(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueueState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueueState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueueState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CleanBatch != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.CleanBatch))
		i--
		dAtA[i] = 0x30
	}
	if m.MaxAlive != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.MaxAlive))
		i--
		dAtA[i] = 0x28
	}
	if m.Timeout != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x20
	}
	if len(m.States) > 0 {
		for iNdEx := len(m.States) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.States[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Consumers != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Consumers))
		i--
		dAtA[i] = 0x10
	}
	if m.Partitions != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Partitions))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Partiton) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Partiton) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Partiton) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastFetchTS != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.LastFetchTS))
		i--
		dAtA[i] = 0x18
	}
	if m.Version != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x10
	}
	if m.Consumer != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Consumer))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CallbackAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CallbackAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CallbackAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateTenantInitState != nil {
		{
			size, err := m.UpdateTenantInitState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.SetKV != nil {
		{
			size, err := m.SetKV.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMeta(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SetKVAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetKVAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetKVAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Group != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.KV.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMeta(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *TenantInitStateUpdateAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TenantInitStateUpdateAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantInitStateUpdateAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Group != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintMeta(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TenantRunnerOffsets) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TenantRunnerOffsets) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantRunnerOffsets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Offsets) > 0 {
		for iNdEx := len(m.Offsets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Offsets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMeta(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Workers) > 0 {
		for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Workers[iNdEx])
			copy(dAtA[i:], m.Workers[iNdEx])
			i = encodeVarintMeta(dAtA, i, uint64(len(m.Workers[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TenantRunnerWorkerOffsets) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TenantRunnerWorkerOffsets) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantRunnerWorkerOffsets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Offsets) > 0 {
		dAtA22 := make([]byte, len(m.Offsets)*10)
		var j21 int
		for _, num := range m.Offsets {
			for num >= 1<<7 {
				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j21++
			}
			dAtA22[j21] = uint8(num)
			j21++
		}
		i -= j21
		copy(dAtA[i:], dAtA22[:j21])
		i = encodeVarintMeta(dAtA, i, uint64(j21))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintMeta(dAtA []byte, offset int, v uint64) int {
	offset -= sovMeta(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TenantQueue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Partitions != 0 {
		n += 1 + sovMeta(uint64(m.Partitions))
	}
	if m.ConsumerTimeout != 0 {
		n += 1 + sovMeta(uint64(m.ConsumerTimeout))
	}
	if m.MaxAlive != 0 {
		n += 1 + sovMeta(uint64(m.MaxAlive))
	}
	if m.CleanBatch != 0 {
		n += 1 + sovMeta(uint64(m.CleanBatch))
	}
	return n
}

func (m *Tenant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovMeta(uint64(m.ID))
	}
	l = m.Input.Size()
	n += 1 + l + sovMeta(uint64(l))
	l = m.Output.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.Runners != 0 {
		n += 1 + sovMeta(uint64(m.Runners))
	}
	if len(m.InputsState) > 0 {
		n += 1 + sovMeta(uint64(len(m.InputsState))) + len(m.InputsState)*1
	}
	if len(m.OutputsState) > 0 {
		n += 1 + sovMeta(uint64(len(m.OutputsState))) + len(m.OutputsState)*1
	}
	if len(m.RunnersState) > 0 {
		n += 1 + sovMeta(uint64(len(m.RunnersState))) + len(m.RunnersState)*1
	}
	return n
}

func (m *WorkerRunner) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovMeta(uint64(m.ID))
	}
	if m.Index != 0 {
		n += 1 + sovMeta(uint64(m.Index))
	}
	if m.State != 0 {
		n += 1 + sovMeta(uint64(m.State))
	}
	if len(m.Workers) > 0 {
		for _, e := range m.Workers {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if m.TotalCrowd != 0 {
		n += 1 + sovMeta(uint64(m.TotalCrowd))
	}
	return n
}

func (m *WorkflowWorker) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.WorkflowID != 0 {
		n += 1 + sovMeta(uint64(m.WorkflowID))
	}
	if m.InstanceID != 0 {
		n += 1 + sovMeta(uint64(m.InstanceID))
	}
	if m.Index != 0 {
		n += 1 + sovMeta(uint64(m.Index))
	}
	return n
}

func (m *ShardBitmapPutMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.TTL != 0 {
		n += 1 + sovMeta(uint64(m.TTL))
	}
	if m.BytesPerShard != 0 {
		n += 1 + sovMeta(uint64(m.BytesPerShard))
	}
	return n
}

func (m *ShardBitmapLoadMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.Total != 0 {
		n += 1 + sovMeta(uint64(m.Total))
	}
	if m.Shards != 0 {
		n += 1 + sovMeta(uint64(m.Shards))
	}
	return n
}

func (m *IDValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *IDSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Values) > 0 {
		for _, e := range m.Values {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	return n
}

func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMeta(uint64(m.Type))
	}
	if m.User != nil {
		l = m.User.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.UpdateCrowd != nil {
		l = m.UpdateCrowd.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.UpdateWorkflow != nil {
		l = m.UpdateWorkflow.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *UpdateCrowdEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.WorkflowID != 0 {
		n += 1 + sovMeta(uint64(m.WorkflowID))
	}
	if m.Index != 0 {
		n += 1 + sovMeta(uint64(m.Index))
	}
	l = len(m.Crowd)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *UpdateWorkflowEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Workflow.Size()
	n += 1 + l + sovMeta(uint64(l))
	return n
}

func (m *UserEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserID != 0 {
		n += 1 + sovMeta(uint64(m.UserID))
	}
	if m.TenantID != 0 {
		n += 1 + sovMeta(uint64(m.TenantID))
	}
	if len(m.Data) > 0 {
		for _, e := range m.Data {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	return n
}

func (m *KV) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *Notify) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserID != 0 {
		n += 1 + sovMeta(uint64(m.UserID))
	}
	l = len(m.Crowd)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.TenantID != 0 {
		n += 1 + sovMeta(uint64(m.TenantID))
	}
	if m.WorkflowID != 0 {
		n += 1 + sovMeta(uint64(m.WorkflowID))
	}
	if m.InstanceID != 0 {
		n += 1 + sovMeta(uint64(m.InstanceID))
	}
	l = len(m.FromStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.FromAction)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.ToStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.ToAction)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.ToStepCycleTTL != 0 {
		n += 1 + sovMeta(uint64(m.ToStepCycleTTL))
	}
	return n
}

func (m *Workflow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovMeta(uint64(m.ID))
	}
	if m.TenantID != 0 {
		n += 1 + sovMeta(uint64(m.TenantID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if len(m.Steps) > 0 {
		for _, e := range m.Steps {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if m.StopAt != 0 {
		n += 1 + sovMeta(uint64(m.StopAt))
	}
	return n
}

func (m *WorkflowInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Snapshot.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.InstanceID != 0 {
		n += 1 + sovMeta(uint64(m.InstanceID))
	}
	l = len(m.LoaderMeta)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.Loader != 0 {
		n += 1 + sovMeta(uint64(m.Loader))
	}
	if m.TotalCrowd != 0 {
		n += 1 + sovMeta(uint64(m.TotalCrowd))
	}
	if m.StartedAt != 0 {
		n += 1 + sovMeta(uint64(m.StartedAt))
	}
	if m.StoppedAt != 0 {
		n += 1 + sovMeta(uint64(m.StoppedAt))
	}
	if m.Version != 0 {
		n += 1 + sovMeta(uint64(m.Version))
	}
	if m.State != 0 {
		n += 1 + sovMeta(uint64(m.State))
	}
	return n
}

func (m *WorkflowInstanceSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Snapshot.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.Timestamp != 0 {
		n += 1 + sovMeta(uint64(m.Timestamp))
	}
	if len(m.States) > 0 {
		for _, e := range m.States {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	return n
}

func (m *WorkflowInstanceWorkerState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TenantID != 0 {
		n += 1 + sovMeta(uint64(m.TenantID))
	}
	if m.WorkflowID != 0 {
		n += 1 + sovMeta(uint64(m.WorkflowID))
	}
	if m.InstanceID != 0 {
		n += 1 + sovMeta(uint64(m.InstanceID))
	}
	if m.Index != 0 {
		n += 1 + sovMeta(uint64(m.Index))
	}
	if len(m.States) > 0 {
		for _, e := range m.States {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if m.Version != 0 {
		n += 1 + sovMeta(uint64(m.Version))
	}
	if m.StopAt != 0 {
		n += 1 + sovMeta(uint64(m.StopAt))
	}
	if m.Runner != 0 {
		n += 1 + sovMeta(uint64(m.Runner))
	}
	return n
}

func (m *CountState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Step)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.Count != 0 {
		n += 1 + sovMeta(uint64(m.Count))
	}
	return n
}

func (m *InstanceCountState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Snapshot.Size()
	n += 1 + l + sovMeta(uint64(l))
	if len(m.States) > 0 {
		for _, e := range m.States {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if m.Total != 0 {
		n += 1 + sovMeta(uint64(m.Total))
	}
	return n
}

func (m *StepState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Step.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.TotalCrowd != 0 {
		n += 1 + sovMeta(uint64(m.TotalCrowd))
	}
	if m.Loader != 0 {
		n += 1 + sovMeta(uint64(m.Loader))
	}
	l = len(m.LoaderMeta)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *Step) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = m.Execution.Size()
	n += 1 + l + sovMeta(uint64(l))
	l = len(m.EnterAction)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.LeaveAction)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.TTL != 0 {
		n += 1 + sovMeta(uint64(m.TTL))
	}
	return n
}

func (m *Execution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMeta(uint64(m.Type))
	}
	if m.Timer != nil {
		l = m.Timer.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.Direct != nil {
		l = m.Direct.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	if len(m.Branches) > 0 {
		for _, e := range m.Branches {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	l = m.Parallel.Size()
	n += 1 + l + sovMeta(uint64(l))
	return n
}

func (m *TimerExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Condition != nil {
		l = m.Condition.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.Cron)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.NextStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.UseStepCrowdToDrive {
		n += 2
	}
	return n
}

func (m *ParallelExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NextStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if len(m.Parallels) > 0 {
		for _, e := range m.Parallels {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	return n
}

func (m *DirectExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NextStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *ConditionExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Condition.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.Execution != nil {
		l = m.Execution.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	l = len(m.NextStep)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *Expr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovMeta(uint64(m.Type))
	}
	return n
}

func (m *QueueState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Partitions != 0 {
		n += 1 + sovMeta(uint64(m.Partitions))
	}
	if m.Consumers != 0 {
		n += 1 + sovMeta(uint64(m.Consumers))
	}
	if len(m.States) > 0 {
		for _, e := range m.States {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if m.Timeout != 0 {
		n += 1 + sovMeta(uint64(m.Timeout))
	}
	if m.MaxAlive != 0 {
		n += 1 + sovMeta(uint64(m.MaxAlive))
	}
	if m.CleanBatch != 0 {
		n += 1 + sovMeta(uint64(m.CleanBatch))
	}
	return n
}

func (m *Partiton) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Consumer != 0 {
		n += 1 + sovMeta(uint64(m.Consumer))
	}
	if m.Version != 0 {
		n += 1 + sovMeta(uint64(m.Version))
	}
	if m.LastFetchTS != 0 {
		n += 1 + sovMeta(uint64(m.LastFetchTS))
	}
	return n
}

func (m *CallbackAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SetKV != nil {
		l = m.SetKV.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	if m.UpdateTenantInitState != nil {
		l = m.UpdateTenantInitState.Size()
		n += 1 + l + sovMeta(uint64(l))
	}
	return n
}

func (m *SetKVAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KV.Size()
	n += 1 + l + sovMeta(uint64(l))
	if m.Group != 0 {
		n += 1 + sovMeta(uint64(m.Group))
	}
	return n
}

func (m *TenantInitStateUpdateAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovMeta(uint64(m.ID))
	}
	if m.Index != 0 {
		n += 1 + sovMeta(uint64(m.Index))
	}
	if m.Group != 0 {
		n += 1 + sovMeta(uint64(m.Group))
	}
	return n
}

func (m *TenantRunnerOffsets) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Workers) > 0 {
		for _, s := range m.Workers {
			l = len(s)
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	if len(m.Offsets) > 0 {
		for _, e := range m.Offsets {
			l = e.Size()
			n += 1 + l + sovMeta(uint64(l))
		}
	}
	return n
}

func (m *TenantRunnerWorkerOffsets) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Offsets) > 0 {
		l = 0
		for _, e := range m.Offsets {
			l += sovMeta(uint64(e))
		}
		n += 1 + sovMeta(uint64(l)) + l
	}
	return n
}

func sovMeta(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMeta(x uint64) (n int) {
	return sovMeta(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TenantQueue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TenantQueue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TenantQueue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType)
			}
			m.Partitions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Partitions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerTimeout", wireType)
			}
			m.ConsumerTimeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConsumerTimeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxAlive", wireType)
			}
			m.MaxAlive = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxAlive |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CleanBatch", wireType)
			}
			m.CleanBatch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CleanBatch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Tenant) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Tenant: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tenant: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Input.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Runners", wireType)
			}
			m.Runners = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Runners |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.InputsState = append(m.InputsState, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMeta
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMeta
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.InputsState) == 0 {
					m.InputsState = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMeta
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.InputsState = append(m.InputsState, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field InputsState", wireType)
			}
		case 6:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.OutputsState = append(m.OutputsState, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMeta
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMeta
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.OutputsState) == 0 {
					m.OutputsState = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMeta
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.OutputsState = append(m.OutputsState, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputsState", wireType)
			}
		case 7:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RunnersState = append(m.RunnersState, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMeta
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMeta
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.RunnersState) == 0 {
					m.RunnersState = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMeta
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RunnersState = append(m.RunnersState, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RunnersState", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkerRunner) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkerRunner: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkerRunner: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= WorkerRunnerState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Workers = append(m.Workers, WorkflowWorker{})
			if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalCrowd", wireType)
			}
			m.TotalCrowd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalCrowd |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkflowWorker) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkflowWorker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkflowWorker: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowID", wireType)
			}
			m.WorkflowID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkflowID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardBitmapPutMeta) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ShardBitmapPutMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardBitmapPutMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesPerShard", wireType)
			}
			m.BytesPerShard = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesPerShard |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardBitmapLoadMeta) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ShardBitmapLoadMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardBitmapLoadMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
			}
			m.Shards = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Shards |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IDValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IDValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IDValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IDSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IDSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IDSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, IDValue{})
			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Event) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Event: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= EventType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.User == nil {
				m.User = &UserEvent{}
			}
			if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateCrowd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateCrowd == nil {
				m.UpdateCrowd = &UpdateCrowdEvent{}
			}
			if err := m.UpdateCrowd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateWorkflow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateWorkflow == nil {
				m.UpdateWorkflow = &UpdateWorkflowEvent{}
			}
			if err := m.UpdateWorkflow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateCrowdEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateCrowdEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateCrowdEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowID", wireType)
			}
			m.WorkflowID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkflowID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Crowd", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Crowd = append(m.Crowd[:0], dAtA[iNdEx:postIndex]...)
			if m.Crowd == nil {
				m.Crowd = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateWorkflowEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateWorkflowEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateWorkflowEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Workflow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Workflow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UserEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			m.UserID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantID", wireType)
			}
			m.TenantID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TenantID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data, KV{})
			if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KV) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KV: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KV: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Notify) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Notify: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Notify: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			m.UserID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Crowd", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Crowd = append(m.Crowd[:0], dAtA[iNdEx:postIndex]...)
			if m.Crowd == nil {
				m.Crowd = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantID", wireType)
			}
			m.TenantID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TenantID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowID", wireType)
			}
			m.WorkflowID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkflowID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromAction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToStepCycleTTL", wireType)
			}
			m.ToStepCycleTTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ToStepCycleTTL |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Workflow) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Workflow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Workflow: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantID", wireType)
			}
			m.TenantID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TenantID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Steps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Steps = append(m.Steps, Step{})
			if err := m.Steps[len(m.Steps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopAt", wireType)
			}
			m.StopAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkflowInstance) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkflowInstance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkflowInstance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoaderMeta", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoaderMeta = append(m.LoaderMeta[:0], dAtA[iNdEx:postIndex]...)
			if m.LoaderMeta == nil {
				m.LoaderMeta = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Loader", wireType)
			}
			m.Loader = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Loader |= BMLoader(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalCrowd", wireType)
			}
			m.TotalCrowd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalCrowd |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType)
			}
			m.StartedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoppedAt", wireType)
			}
			m.StoppedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoppedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= WorkflowInstanceState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkflowInstanceSnapshot) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkflowInstanceSnapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkflowInstanceSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field States", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.States = append(m.States, StepState{})
			if err := m.States[len(m.States)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkflowInstanceWorkerState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkflowInstanceWorkerState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkflowInstanceWorkerState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantID", wireType)
			}
			m.TenantID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TenantID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowID", wireType)
			}
			m.WorkflowID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkflowID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field States", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.States = append(m.States, StepState{})
			if err := m.States[len(m.States)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopAt", wireType)
			}
			m.StopAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Runner", wireType)
			}
			m.Runner = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Runner |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CountState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CountState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CountState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Step = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InstanceCountState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InstanceCountState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InstanceCountState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field States", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.States = append(m.States, CountState{})
			if err := m.States[len(m.States)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StepState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StepState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StepState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Step.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalCrowd", wireType)
			}
			m.TotalCrowd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalCrowd |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Loader", wireType)
			}
			m.Loader = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Loader |= BMLoader(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoaderMeta", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoaderMeta = append(m.LoaderMeta[:0], dAtA[iNdEx:postIndex]...)
			if m.LoaderMeta == nil {
				m.LoaderMeta = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Step) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Step: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Step: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Execution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Execution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnterAction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EnterAction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaveAction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LeaveAction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			m.TTL = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TTL |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Execution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Execution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Execution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ExectuionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timer == nil {
				m.Timer = &TimerExecution{}
			}
			if err := m.Timer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direct", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Direct == nil {
				m.Direct = &DirectExecution{}
			}
			if err := m.Direct.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Branches", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Branches = append(m.Branches, ConditionExecution{})
			if err := m.Branches[len(m.Branches)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Parallel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Parallel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TimerExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TimerExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TimerExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Condition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Condition == nil {
				m.Condition = &Expr{}
			}
			if err := m.Condition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cron", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cron = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseStepCrowdToDrive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseStepCrowdToDrive = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParallelExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ParallelExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParallelExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Parallels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Parallels = append(m.Parallels, Execution{})
			if err := m.Parallels[len(m.Parallels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DirectExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DirectExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DirectExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConditionExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConditionExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConditionExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Condition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Condition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Execution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Execution == nil {
				m.Execution = &Execution{}
			}
			if err := m.Execution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextStep", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextStep = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Expr) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Expr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Expr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ExprResultType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueueState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueueState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType)
			}
			m.Partitions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Partitions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Consumers", wireType)
			}
			m.Consumers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Consumers |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field States", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.States = append(m.States, Partiton{})
			if err := m.States[len(m.States)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxAlive", wireType)
			}
			m.MaxAlive = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxAlive |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CleanBatch", wireType)
			}
			m.CleanBatch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CleanBatch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Partiton) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Partiton: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Partiton: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Consumer", wireType)
			}
			m.Consumer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Consumer |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastFetchTS", wireType)
			}
			m.LastFetchTS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastFetchTS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CallbackAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CallbackAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CallbackAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetKV", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SetKV == nil {
				m.SetKV = &SetKVAction{}
			}
			if err := m.SetKV.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTenantInitState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateTenantInitState == nil {
				m.UpdateTenantInitState = &TenantInitStateUpdateAction{}
			}
			if err := m.UpdateTenantInitState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetKVAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetKVAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetKVAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KV", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KV.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= Group(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TenantInitStateUpdateAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TenantInitStateUpdateAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TenantInitStateUpdateAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= Group(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TenantRunnerOffsets) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TenantRunnerOffsets: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TenantRunnerOffsets: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Workers = append(m.Workers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offsets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMeta
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMeta
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Offsets = append(m.Offsets, &TenantRunnerWorkerOffsets{})
			if err := m.Offsets[len(m.Offsets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TenantRunnerWorkerOffsets) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TenantRunnerWorkerOffsets: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TenantRunnerWorkerOffsets: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Offsets = append(m.Offsets, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMeta
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMeta
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMeta
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Offsets) == 0 {
					m.Offsets = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMeta
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Offsets = append(m.Offsets, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Offsets", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMeta(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMeta
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMeta(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMeta
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMeta
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMeta
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMeta
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMeta
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMeta        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMeta          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMeta = fmt.Errorf("proto: unexpected end of group")
)