// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v3.19.0
// source: interservice/cereal/cereal.proto

package cereal

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type Task struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty" toml:"name,omitempty" mapstructure:"name,omitempty"`
	Parameters    []byte                 `protobuf:"bytes,2,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	StartAfter    *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_after,json=startAfter,proto3" json:"start_after,omitempty" toml:"start_after,omitempty" mapstructure:"start_after,omitempty"`
	Metadata      *TaskMetadata          `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty" toml:"metadata,omitempty" mapstructure:"metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Task) ProtoMessage() {}

func (x *Task) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Task.ProtoReflect.Descriptor instead.
func (*Task) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{0}
}

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

func (x *Task) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *Task) GetStartAfter() *timestamppb.Timestamp {
	if x != nil {
		return x.StartAfter
	}
	return nil
}

func (x *Task) GetMetadata() *TaskMetadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

type TaskMetadata struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EnqueuedAt    *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=enqueued_at,json=enqueuedAt,proto3" json:"enqueued_at,omitempty" toml:"enqueued_at,omitempty" mapstructure:"enqueued_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TaskMetadata) ProtoMessage() {}

func (x *TaskMetadata) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskMetadata.ProtoReflect.Descriptor instead.
func (*TaskMetadata) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{1}
}

func (x *TaskMetadata) GetEnqueuedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.EnqueuedAt
	}
	return nil
}

type WorkflowInstance struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	Status        string                 `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty" toml:"status,omitempty" mapstructure:"status,omitempty"`
	Parameters    []byte                 `protobuf:"bytes,5,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	Payload       []byte                 `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty" toml:"payload,omitempty" mapstructure:"payload,omitempty"`
	Result        []byte                 `protobuf:"bytes,7,opt,name=result,proto3" json:"result,omitempty" toml:"result,omitempty" mapstructure:"result,omitempty"`
	Err           string                 `protobuf:"bytes,8,opt,name=err,proto3" json:"err,omitempty" toml:"err,omitempty" mapstructure:"err,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WorkflowInstance) ProtoMessage() {}

func (x *WorkflowInstance) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkflowInstance.ProtoReflect.Descriptor instead.
func (*WorkflowInstance) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{2}
}

func (x *WorkflowInstance) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *WorkflowInstance) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *WorkflowInstance) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

func (x *WorkflowInstance) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

func (x *WorkflowInstance) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *WorkflowInstance) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *WorkflowInstance) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}

func (x *WorkflowInstance) GetErr() string {
	if x != nil {
		return x.Err
	}
	return ""
}

type TaskResult struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TaskName      string                 `protobuf:"bytes,1,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty" toml:"task_name,omitempty" mapstructure:"task_name,omitempty"`
	Parameters    []byte                 `protobuf:"bytes,2,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	Status        string                 `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty" toml:"status,omitempty" mapstructure:"status,omitempty"`
	ErrorText     string                 `protobuf:"bytes,4,opt,name=error_text,json=errorText,proto3" json:"error_text,omitempty" toml:"error_text,omitempty" mapstructure:"error_text,omitempty"`
	Result        []byte                 `protobuf:"bytes,5,opt,name=result,proto3" json:"result,omitempty" toml:"result,omitempty" mapstructure:"result,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TaskResult) ProtoMessage() {}

func (x *TaskResult) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TaskResult.ProtoReflect.Descriptor instead.
func (*TaskResult) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{3}
}

func (x *TaskResult) GetTaskName() string {
	if x != nil {
		return x.TaskName
	}
	return ""
}

func (x *TaskResult) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *TaskResult) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

func (x *TaskResult) GetErrorText() string {
	if x != nil {
		return x.ErrorText
	}
	return ""
}

func (x *TaskResult) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}

type WorkflowEvent struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	Type               string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty" toml:"type,omitempty" mapstructure:"type,omitempty"`
	EnqueuedTaskCount  int64                  `protobuf:"varint,2,opt,name=enqueued_task_count,json=enqueuedTaskCount,proto3" json:"enqueued_task_count,omitempty" toml:"enqueued_task_count,omitempty" mapstructure:"enqueued_task_count,omitempty"`
	CompletedTaskCount int64                  `protobuf:"varint,3,opt,name=completed_task_count,json=completedTaskCount,proto3" json:"completed_task_count,omitempty" toml:"completed_task_count,omitempty" mapstructure:"completed_task_count,omitempty"`
	TaskResult         *TaskResult            `protobuf:"bytes,4,opt,name=task_result,json=taskResult,proto3" json:"task_result,omitempty" toml:"task_result,omitempty" mapstructure:"task_result,omitempty"`
	EnqueuedAt         *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=enqueued_at,json=enqueuedAt,proto3" json:"enqueued_at,omitempty" toml:"enqueued_at,omitempty" mapstructure:"enqueued_at,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*WorkflowEvent) ProtoMessage() {}

func (x *WorkflowEvent) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WorkflowEvent.ProtoReflect.Descriptor instead.
func (*WorkflowEvent) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{4}
}

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

func (x *WorkflowEvent) GetEnqueuedTaskCount() int64 {
	if x != nil {
		return x.EnqueuedTaskCount
	}
	return 0
}

func (x *WorkflowEvent) GetCompletedTaskCount() int64 {
	if x != nil {
		return x.CompletedTaskCount
	}
	return 0
}

func (x *WorkflowEvent) GetTaskResult() *TaskResult {
	if x != nil {
		return x.TaskResult
	}
	return nil
}

func (x *WorkflowEvent) GetEnqueuedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.EnqueuedAt
	}
	return nil
}

type DequeueWorkflowRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cmd:
	//
	//	*DequeueWorkflowRequest_Dequeue_
	//	*DequeueWorkflowRequest_Continue_
	//	*DequeueWorkflowRequest_Done_
	//	*DequeueWorkflowRequest_Fail_
	Cmd           isDequeueWorkflowRequest_Cmd `protobuf_oneof:"cmd"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DequeueWorkflowRequest) ProtoMessage() {}

func (x *DequeueWorkflowRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowRequest.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{5}
}

func (x *DequeueWorkflowRequest) GetCmd() isDequeueWorkflowRequest_Cmd {
	if x != nil {
		return x.Cmd
	}
	return nil
}

func (x *DequeueWorkflowRequest) GetDequeue() *DequeueWorkflowRequest_Dequeue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowRequest_Dequeue_); ok {
			return x.Dequeue
		}
	}
	return nil
}

func (x *DequeueWorkflowRequest) GetContinue() *DequeueWorkflowRequest_Continue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowRequest_Continue_); ok {
			return x.Continue
		}
	}
	return nil
}

func (x *DequeueWorkflowRequest) GetDone() *DequeueWorkflowRequest_Done {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowRequest_Done_); ok {
			return x.Done
		}
	}
	return nil
}

func (x *DequeueWorkflowRequest) GetFail() *DequeueWorkflowRequest_Fail {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowRequest_Fail_); ok {
			return x.Fail
		}
	}
	return nil
}

type isDequeueWorkflowRequest_Cmd interface {
	isDequeueWorkflowRequest_Cmd()
}

type DequeueWorkflowRequest_Dequeue_ struct {
	Dequeue *DequeueWorkflowRequest_Dequeue `protobuf:"bytes,1,opt,name=dequeue,proto3,oneof"`
}

type DequeueWorkflowRequest_Continue_ struct {
	Continue *DequeueWorkflowRequest_Continue `protobuf:"bytes,2,opt,name=continue,proto3,oneof"`
}

type DequeueWorkflowRequest_Done_ struct {
	Done *DequeueWorkflowRequest_Done `protobuf:"bytes,3,opt,name=done,proto3,oneof"`
}

type DequeueWorkflowRequest_Fail_ struct {
	Fail *DequeueWorkflowRequest_Fail `protobuf:"bytes,4,opt,name=fail,proto3,oneof"`
}

func (*DequeueWorkflowRequest_Dequeue_) isDequeueWorkflowRequest_Cmd() {}

func (*DequeueWorkflowRequest_Continue_) isDequeueWorkflowRequest_Cmd() {}

func (*DequeueWorkflowRequest_Done_) isDequeueWorkflowRequest_Cmd() {}

func (*DequeueWorkflowRequest_Fail_) isDequeueWorkflowRequest_Cmd() {}

type DequeueWorkflowChunkRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cmd:
	//
	//	*DequeueWorkflowChunkRequest_Dequeue_
	//	*DequeueWorkflowChunkRequest_Continue_
	//	*DequeueWorkflowChunkRequest_Done_
	//	*DequeueWorkflowChunkRequest_Fail_
	Cmd           isDequeueWorkflowChunkRequest_Cmd `protobuf_oneof:"cmd"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DequeueWorkflowChunkRequest) ProtoMessage() {}

func (x *DequeueWorkflowChunkRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkRequest.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{6}
}

func (x *DequeueWorkflowChunkRequest) GetCmd() isDequeueWorkflowChunkRequest_Cmd {
	if x != nil {
		return x.Cmd
	}
	return nil
}

func (x *DequeueWorkflowChunkRequest) GetDequeue() *DequeueWorkflowChunkRequest_Dequeue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowChunkRequest_Dequeue_); ok {
			return x.Dequeue
		}
	}
	return nil
}

func (x *DequeueWorkflowChunkRequest) GetContinue() *DequeueWorkflowChunkRequest_Continue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowChunkRequest_Continue_); ok {
			return x.Continue
		}
	}
	return nil
}

func (x *DequeueWorkflowChunkRequest) GetDone() *DequeueWorkflowChunkRequest_Done {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowChunkRequest_Done_); ok {
			return x.Done
		}
	}
	return nil
}

func (x *DequeueWorkflowChunkRequest) GetFail() *DequeueWorkflowChunkRequest_Fail {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowChunkRequest_Fail_); ok {
			return x.Fail
		}
	}
	return nil
}

type isDequeueWorkflowChunkRequest_Cmd interface {
	isDequeueWorkflowChunkRequest_Cmd()
}

type DequeueWorkflowChunkRequest_Dequeue_ struct {
	Dequeue *DequeueWorkflowChunkRequest_Dequeue `protobuf:"bytes,1,opt,name=dequeue,proto3,oneof"`
}

type DequeueWorkflowChunkRequest_Continue_ struct {
	Continue *DequeueWorkflowChunkRequest_Continue `protobuf:"bytes,2,opt,name=continue,proto3,oneof"`
}

type DequeueWorkflowChunkRequest_Done_ struct {
	Done *DequeueWorkflowChunkRequest_Done `protobuf:"bytes,3,opt,name=done,proto3,oneof"`
}

type DequeueWorkflowChunkRequest_Fail_ struct {
	Fail *DequeueWorkflowChunkRequest_Fail `protobuf:"bytes,4,opt,name=fail,proto3,oneof"`
}

func (*DequeueWorkflowChunkRequest_Dequeue_) isDequeueWorkflowChunkRequest_Cmd() {}

func (*DequeueWorkflowChunkRequest_Continue_) isDequeueWorkflowChunkRequest_Cmd() {}

func (*DequeueWorkflowChunkRequest_Done_) isDequeueWorkflowChunkRequest_Cmd() {}

func (*DequeueWorkflowChunkRequest_Fail_) isDequeueWorkflowChunkRequest_Cmd() {}

type DequeueWorkflowResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cmd:
	//
	//	*DequeueWorkflowResponse_Dequeue_
	//	*DequeueWorkflowResponse_Status_
	//	*DequeueWorkflowResponse_Committed_
	Cmd           isDequeueWorkflowResponse_Cmd `protobuf_oneof:"cmd"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DequeueWorkflowResponse) ProtoMessage() {}

func (x *DequeueWorkflowResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowResponse.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{7}
}

func (x *DequeueWorkflowResponse) GetCmd() isDequeueWorkflowResponse_Cmd {
	if x != nil {
		return x.Cmd
	}
	return nil
}

func (x *DequeueWorkflowResponse) GetDequeue() *DequeueWorkflowResponse_Dequeue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowResponse_Dequeue_); ok {
			return x.Dequeue
		}
	}
	return nil
}

func (x *DequeueWorkflowResponse) GetStatus() *DequeueWorkflowResponse_Status {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowResponse_Status_); ok {
			return x.Status
		}
	}
	return nil
}

func (x *DequeueWorkflowResponse) GetCommitted() *DequeueWorkflowResponse_Committed {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueWorkflowResponse_Committed_); ok {
			return x.Committed
		}
	}
	return nil
}

type isDequeueWorkflowResponse_Cmd interface {
	isDequeueWorkflowResponse_Cmd()
}

type DequeueWorkflowResponse_Dequeue_ struct {
	Dequeue *DequeueWorkflowResponse_Dequeue `protobuf:"bytes,1,opt,name=dequeue,proto3,oneof"`
}

type DequeueWorkflowResponse_Status_ struct {
	Status *DequeueWorkflowResponse_Status `protobuf:"bytes,2,opt,name=status,proto3,oneof"`
}

type DequeueWorkflowResponse_Committed_ struct {
	Committed *DequeueWorkflowResponse_Committed `protobuf:"bytes,3,opt,name=committed,proto3,oneof"`
}

func (*DequeueWorkflowResponse_Dequeue_) isDequeueWorkflowResponse_Cmd() {}

func (*DequeueWorkflowResponse_Status_) isDequeueWorkflowResponse_Cmd() {}

func (*DequeueWorkflowResponse_Committed_) isDequeueWorkflowResponse_Cmd() {}

type DequeueWorkflowChunkResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Chunk         []byte                 `protobuf:"bytes,1,opt,name=chunk,proto3" json:"chunk,omitempty" toml:"chunk,omitempty" mapstructure:"chunk,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DequeueWorkflowChunkResponse) ProtoMessage() {}

func (x *DequeueWorkflowChunkResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkResponse.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{8}
}

func (x *DequeueWorkflowChunkResponse) GetChunk() []byte {
	if x != nil {
		return x.Chunk
	}
	return nil
}

type EnqueueWorkflowRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	Parameters    []byte                 `protobuf:"bytes,4,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EnqueueWorkflowRequest) ProtoMessage() {}

func (x *EnqueueWorkflowRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EnqueueWorkflowRequest.ProtoReflect.Descriptor instead.
func (*EnqueueWorkflowRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{9}
}

func (x *EnqueueWorkflowRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *EnqueueWorkflowRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *EnqueueWorkflowRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

func (x *EnqueueWorkflowRequest) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

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

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

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

func (*EnqueueWorkflowResponse) ProtoMessage() {}

func (x *EnqueueWorkflowResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EnqueueWorkflowResponse.ProtoReflect.Descriptor instead.
func (*EnqueueWorkflowResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{10}
}

type CancelWorkflowRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CancelWorkflowRequest) ProtoMessage() {}

func (x *CancelWorkflowRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CancelWorkflowRequest.ProtoReflect.Descriptor instead.
func (*CancelWorkflowRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{11}
}

func (x *CancelWorkflowRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *CancelWorkflowRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *CancelWorkflowRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

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

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

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

func (*CancelWorkflowResponse) ProtoMessage() {}

func (x *CancelWorkflowResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CancelWorkflowResponse.ProtoReflect.Descriptor instead.
func (*CancelWorkflowResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{12}
}

type KillWorkflowRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KillWorkflowRequest) ProtoMessage() {}

func (x *KillWorkflowRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KillWorkflowRequest.ProtoReflect.Descriptor instead.
func (*KillWorkflowRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{13}
}

func (x *KillWorkflowRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *KillWorkflowRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *KillWorkflowRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

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

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

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

func (*KillWorkflowResponse) ProtoMessage() {}

func (x *KillWorkflowResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KillWorkflowResponse.ProtoReflect.Descriptor instead.
func (*KillWorkflowResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{14}
}

type DequeueTaskRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cmd:
	//
	//	*DequeueTaskRequest_Dequeue_
	//	*DequeueTaskRequest_Succeed_
	//	*DequeueTaskRequest_Fail_
	Cmd           isDequeueTaskRequest_Cmd `protobuf_oneof:"cmd"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskRequest) Reset() {
	*x = DequeueTaskRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskRequest) ProtoMessage() {}

func (x *DequeueTaskRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskRequest.ProtoReflect.Descriptor instead.
func (*DequeueTaskRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{15}
}

func (x *DequeueTaskRequest) GetCmd() isDequeueTaskRequest_Cmd {
	if x != nil {
		return x.Cmd
	}
	return nil
}

func (x *DequeueTaskRequest) GetDequeue() *DequeueTaskRequest_Dequeue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskRequest_Dequeue_); ok {
			return x.Dequeue
		}
	}
	return nil
}

func (x *DequeueTaskRequest) GetSucceed() *DequeueTaskRequest_Succeed {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskRequest_Succeed_); ok {
			return x.Succeed
		}
	}
	return nil
}

func (x *DequeueTaskRequest) GetFail() *DequeueTaskRequest_Fail {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskRequest_Fail_); ok {
			return x.Fail
		}
	}
	return nil
}

type isDequeueTaskRequest_Cmd interface {
	isDequeueTaskRequest_Cmd()
}

type DequeueTaskRequest_Dequeue_ struct {
	Dequeue *DequeueTaskRequest_Dequeue `protobuf:"bytes,1,opt,name=dequeue,proto3,oneof"`
}

type DequeueTaskRequest_Succeed_ struct {
	Succeed *DequeueTaskRequest_Succeed `protobuf:"bytes,2,opt,name=succeed,proto3,oneof"`
}

type DequeueTaskRequest_Fail_ struct {
	Fail *DequeueTaskRequest_Fail `protobuf:"bytes,3,opt,name=fail,proto3,oneof"`
}

func (*DequeueTaskRequest_Dequeue_) isDequeueTaskRequest_Cmd() {}

func (*DequeueTaskRequest_Succeed_) isDequeueTaskRequest_Cmd() {}

func (*DequeueTaskRequest_Fail_) isDequeueTaskRequest_Cmd() {}

type DequeueTaskResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cmd:
	//
	//	*DequeueTaskResponse_Dequeue_
	//	*DequeueTaskResponse_Cancel_
	//	*DequeueTaskResponse_Committed_
	Cmd           isDequeueTaskResponse_Cmd `protobuf_oneof:"cmd"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskResponse) Reset() {
	*x = DequeueTaskResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskResponse) ProtoMessage() {}

func (x *DequeueTaskResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskResponse.ProtoReflect.Descriptor instead.
func (*DequeueTaskResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{16}
}

func (x *DequeueTaskResponse) GetCmd() isDequeueTaskResponse_Cmd {
	if x != nil {
		return x.Cmd
	}
	return nil
}

func (x *DequeueTaskResponse) GetDequeue() *DequeueTaskResponse_Dequeue {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskResponse_Dequeue_); ok {
			return x.Dequeue
		}
	}
	return nil
}

func (x *DequeueTaskResponse) GetCancel() *DequeueTaskResponse_Cancel {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskResponse_Cancel_); ok {
			return x.Cancel
		}
	}
	return nil
}

func (x *DequeueTaskResponse) GetCommitted() *DequeueTaskResponse_Committed {
	if x != nil {
		if x, ok := x.Cmd.(*DequeueTaskResponse_Committed_); ok {
			return x.Committed
		}
	}
	return nil
}

type isDequeueTaskResponse_Cmd interface {
	isDequeueTaskResponse_Cmd()
}

type DequeueTaskResponse_Dequeue_ struct {
	Dequeue *DequeueTaskResponse_Dequeue `protobuf:"bytes,1,opt,name=dequeue,proto3,oneof"`
}

type DequeueTaskResponse_Cancel_ struct {
	Cancel *DequeueTaskResponse_Cancel `protobuf:"bytes,2,opt,name=cancel,proto3,oneof"`
}

type DequeueTaskResponse_Committed_ struct {
	Committed *DequeueTaskResponse_Committed `protobuf:"bytes,3,opt,name=committed,proto3,oneof"`
}

func (*DequeueTaskResponse_Dequeue_) isDequeueTaskResponse_Cmd() {}

func (*DequeueTaskResponse_Cancel_) isDequeueTaskResponse_Cmd() {}

func (*DequeueTaskResponse_Committed_) isDequeueTaskResponse_Cmd() {}

type CreateWorkflowScheduleRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	Parameters    []byte                 `protobuf:"bytes,4,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	Enabled       bool                   `protobuf:"varint,5,opt,name=enabled,proto3" json:"enabled,omitempty" toml:"enabled,omitempty" mapstructure:"enabled,omitempty"`
	Recurrence    string                 `protobuf:"bytes,6,opt,name=recurrence,proto3" json:"recurrence,omitempty" toml:"recurrence,omitempty" mapstructure:"recurrence,omitempty"`
	Payload       []byte                 `protobuf:"bytes,7,opt,name=payload,proto3" json:"payload,omitempty" toml:"payload,omitempty" mapstructure:"payload,omitempty"`
	NextRunAt     *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=next_run_at,json=nextRunAt,proto3" json:"next_run_at,omitempty" toml:"next_run_at,omitempty" mapstructure:"next_run_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateWorkflowScheduleRequest) Reset() {
	*x = CreateWorkflowScheduleRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateWorkflowScheduleRequest) ProtoMessage() {}

func (x *CreateWorkflowScheduleRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateWorkflowScheduleRequest.ProtoReflect.Descriptor instead.
func (*CreateWorkflowScheduleRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{17}
}

func (x *CreateWorkflowScheduleRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *CreateWorkflowScheduleRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *CreateWorkflowScheduleRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

func (x *CreateWorkflowScheduleRequest) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *CreateWorkflowScheduleRequest) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

func (x *CreateWorkflowScheduleRequest) GetRecurrence() string {
	if x != nil {
		return x.Recurrence
	}
	return ""
}

func (x *CreateWorkflowScheduleRequest) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *CreateWorkflowScheduleRequest) GetNextRunAt() *timestamppb.Timestamp {
	if x != nil {
		return x.NextRunAt
	}
	return nil
}

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

func (x *CreateWorkflowScheduleResponse) Reset() {
	*x = CreateWorkflowScheduleResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateWorkflowScheduleResponse) ProtoMessage() {}

func (x *CreateWorkflowScheduleResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateWorkflowScheduleResponse.ProtoReflect.Descriptor instead.
func (*CreateWorkflowScheduleResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{18}
}

type ListWorkflowSchedulesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListWorkflowSchedulesRequest) Reset() {
	*x = ListWorkflowSchedulesRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListWorkflowSchedulesRequest) ProtoMessage() {}

func (x *ListWorkflowSchedulesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListWorkflowSchedulesRequest.ProtoReflect.Descriptor instead.
func (*ListWorkflowSchedulesRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{19}
}

func (x *ListWorkflowSchedulesRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

type Schedule struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Domain         string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName   string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName   string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	Parameters     []byte                 `protobuf:"bytes,4,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	Recurrence     string                 `protobuf:"bytes,5,opt,name=recurrence,proto3" json:"recurrence,omitempty" toml:"recurrence,omitempty" mapstructure:"recurrence,omitempty"`
	NextDueAt      *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=next_due_at,json=nextDueAt,proto3" json:"next_due_at,omitempty" toml:"next_due_at,omitempty" mapstructure:"next_due_at,omitempty"`
	LastEnqueuedAt *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=last_enqueued_at,json=lastEnqueuedAt,proto3" json:"last_enqueued_at,omitempty" toml:"last_enqueued_at,omitempty" mapstructure:"last_enqueued_at,omitempty"`
	Enabled        bool                   `protobuf:"varint,8,opt,name=enabled,proto3" json:"enabled,omitempty" toml:"enabled,omitempty" mapstructure:"enabled,omitempty"`
	LastStart      *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_start,json=lastStart,proto3" json:"last_start,omitempty" toml:"last_start,omitempty" mapstructure:"last_start,omitempty"`
	LastEnd        *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=last_end,json=lastEnd,proto3" json:"last_end,omitempty" toml:"last_end,omitempty" mapstructure:"last_end,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *Schedule) Reset() {
	*x = Schedule{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Schedule) ProtoMessage() {}

func (x *Schedule) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Schedule.ProtoReflect.Descriptor instead.
func (*Schedule) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{20}
}

func (x *Schedule) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *Schedule) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *Schedule) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

func (x *Schedule) GetParameters() []byte {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *Schedule) GetRecurrence() string {
	if x != nil {
		return x.Recurrence
	}
	return ""
}

func (x *Schedule) GetNextDueAt() *timestamppb.Timestamp {
	if x != nil {
		return x.NextDueAt
	}
	return nil
}

func (x *Schedule) GetLastEnqueuedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.LastEnqueuedAt
	}
	return nil
}

func (x *Schedule) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

func (x *Schedule) GetLastStart() *timestamppb.Timestamp {
	if x != nil {
		return x.LastStart
	}
	return nil
}

func (x *Schedule) GetLastEnd() *timestamppb.Timestamp {
	if x != nil {
		return x.LastEnd
	}
	return nil
}

type ListWorkflowSchedulesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NumSchedules  int32                  `protobuf:"varint,1,opt,name=num_schedules,json=numSchedules,proto3" json:"num_schedules,omitempty" toml:"num_schedules,omitempty" mapstructure:"num_schedules,omitempty"`
	Schedule      *Schedule              `protobuf:"bytes,2,opt,name=schedule,proto3" json:"schedule,omitempty" toml:"schedule,omitempty" mapstructure:"schedule,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListWorkflowSchedulesResponse) Reset() {
	*x = ListWorkflowSchedulesResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListWorkflowSchedulesResponse) ProtoMessage() {}

func (x *ListWorkflowSchedulesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListWorkflowSchedulesResponse.ProtoReflect.Descriptor instead.
func (*ListWorkflowSchedulesResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{21}
}

func (x *ListWorkflowSchedulesResponse) GetNumSchedules() int32 {
	if x != nil {
		return x.NumSchedules
	}
	return 0
}

func (x *ListWorkflowSchedulesResponse) GetSchedule() *Schedule {
	if x != nil {
		return x.Schedule
	}
	return nil
}

type GetWorkflowScheduleByNameRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetWorkflowScheduleByNameRequest) Reset() {
	*x = GetWorkflowScheduleByNameRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetWorkflowScheduleByNameRequest) ProtoMessage() {}

func (x *GetWorkflowScheduleByNameRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetWorkflowScheduleByNameRequest.ProtoReflect.Descriptor instead.
func (*GetWorkflowScheduleByNameRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{22}
}

func (x *GetWorkflowScheduleByNameRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *GetWorkflowScheduleByNameRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *GetWorkflowScheduleByNameRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

type GetWorkflowScheduleByNameResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Schedule      *Schedule              `protobuf:"bytes,1,opt,name=schedule,proto3" json:"schedule,omitempty" toml:"schedule,omitempty" mapstructure:"schedule,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetWorkflowScheduleByNameResponse) Reset() {
	*x = GetWorkflowScheduleByNameResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetWorkflowScheduleByNameResponse) ProtoMessage() {}

func (x *GetWorkflowScheduleByNameResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetWorkflowScheduleByNameResponse.ProtoReflect.Descriptor instead.
func (*GetWorkflowScheduleByNameResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{23}
}

func (x *GetWorkflowScheduleByNameResponse) GetSchedule() *Schedule {
	if x != nil {
		return x.Schedule
	}
	return nil
}

type UpdateWorkflowScheduleByNameRequest struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	Domain        string                  `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                  `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                  `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	Enabled       *wrapperspb.BoolValue   `protobuf:"bytes,4,opt,name=enabled,proto3" json:"enabled,omitempty" toml:"enabled,omitempty" mapstructure:"enabled,omitempty"`
	Parameters    *wrapperspb.BytesValue  `protobuf:"bytes,5,opt,name=parameters,proto3" json:"parameters,omitempty" toml:"parameters,omitempty" mapstructure:"parameters,omitempty"`
	Recurrence    *wrapperspb.StringValue `protobuf:"bytes,6,opt,name=recurrence,proto3" json:"recurrence,omitempty" toml:"recurrence,omitempty" mapstructure:"recurrence,omitempty"`
	NextRunAt     *timestamppb.Timestamp  `protobuf:"bytes,7,opt,name=next_run_at,json=nextRunAt,proto3" json:"next_run_at,omitempty" toml:"next_run_at,omitempty" mapstructure:"next_run_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateWorkflowScheduleByNameRequest) Reset() {
	*x = UpdateWorkflowScheduleByNameRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UpdateWorkflowScheduleByNameRequest) ProtoMessage() {}

func (x *UpdateWorkflowScheduleByNameRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[24]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateWorkflowScheduleByNameRequest.ProtoReflect.Descriptor instead.
func (*UpdateWorkflowScheduleByNameRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{24}
}

func (x *UpdateWorkflowScheduleByNameRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *UpdateWorkflowScheduleByNameRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *UpdateWorkflowScheduleByNameRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

func (x *UpdateWorkflowScheduleByNameRequest) GetEnabled() *wrapperspb.BoolValue {
	if x != nil {
		return x.Enabled
	}
	return nil
}

func (x *UpdateWorkflowScheduleByNameRequest) GetParameters() *wrapperspb.BytesValue {
	if x != nil {
		return x.Parameters
	}
	return nil
}

func (x *UpdateWorkflowScheduleByNameRequest) GetRecurrence() *wrapperspb.StringValue {
	if x != nil {
		return x.Recurrence
	}
	return nil
}

func (x *UpdateWorkflowScheduleByNameRequest) GetNextRunAt() *timestamppb.Timestamp {
	if x != nil {
		return x.NextRunAt
	}
	return nil
}

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

func (x *UpdateWorkflowScheduleByNameResponse) Reset() {
	*x = UpdateWorkflowScheduleByNameResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UpdateWorkflowScheduleByNameResponse) ProtoMessage() {}

func (x *UpdateWorkflowScheduleByNameResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[25]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpdateWorkflowScheduleByNameResponse.ProtoReflect.Descriptor instead.
func (*UpdateWorkflowScheduleByNameResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{25}
}

type GetWorkflowInstanceByNameRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	InstanceName  string                 `protobuf:"bytes,2,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	WorkflowName  string                 `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetWorkflowInstanceByNameRequest) Reset() {
	*x = GetWorkflowInstanceByNameRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetWorkflowInstanceByNameRequest) ProtoMessage() {}

func (x *GetWorkflowInstanceByNameRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[26]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetWorkflowInstanceByNameRequest.ProtoReflect.Descriptor instead.
func (*GetWorkflowInstanceByNameRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{26}
}

func (x *GetWorkflowInstanceByNameRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *GetWorkflowInstanceByNameRequest) GetInstanceName() string {
	if x != nil {
		return x.InstanceName
	}
	return ""
}

func (x *GetWorkflowInstanceByNameRequest) GetWorkflowName() string {
	if x != nil {
		return x.WorkflowName
	}
	return ""
}

type GetWorkflowInstanceByNameResponse struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	WorkflowInstance *WorkflowInstance      `protobuf:"bytes,1,opt,name=workflow_instance,json=workflowInstance,proto3" json:"workflow_instance,omitempty" toml:"workflow_instance,omitempty" mapstructure:"workflow_instance,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *GetWorkflowInstanceByNameResponse) Reset() {
	*x = GetWorkflowInstanceByNameResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetWorkflowInstanceByNameResponse) ProtoMessage() {}

func (x *GetWorkflowInstanceByNameResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[27]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetWorkflowInstanceByNameResponse.ProtoReflect.Descriptor instead.
func (*GetWorkflowInstanceByNameResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{27}
}

func (x *GetWorkflowInstanceByNameResponse) GetWorkflowInstance() *WorkflowInstance {
	if x != nil {
		return x.WorkflowInstance
	}
	return nil
}

type ListWorkflowInstancesRequest struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	Domain        string                  `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	WorkflowName  *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty" toml:"workflow_name,omitempty" mapstructure:"workflow_name,omitempty"`
	InstanceName  *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty" toml:"instance_name,omitempty" mapstructure:"instance_name,omitempty"`
	IsRunning     *wrapperspb.BoolValue   `protobuf:"bytes,4,opt,name=is_running,json=isRunning,proto3" json:"is_running,omitempty" toml:"is_running,omitempty" mapstructure:"is_running,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListWorkflowInstancesRequest) Reset() {
	*x = ListWorkflowInstancesRequest{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListWorkflowInstancesRequest) ProtoMessage() {}

func (x *ListWorkflowInstancesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[28]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListWorkflowInstancesRequest.ProtoReflect.Descriptor instead.
func (*ListWorkflowInstancesRequest) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{28}
}

func (x *ListWorkflowInstancesRequest) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *ListWorkflowInstancesRequest) GetWorkflowName() *wrapperspb.StringValue {
	if x != nil {
		return x.WorkflowName
	}
	return nil
}

func (x *ListWorkflowInstancesRequest) GetInstanceName() *wrapperspb.StringValue {
	if x != nil {
		return x.InstanceName
	}
	return nil
}

func (x *ListWorkflowInstancesRequest) GetIsRunning() *wrapperspb.BoolValue {
	if x != nil {
		return x.IsRunning
	}
	return nil
}

type ListWorkflowInstancesResponse struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	WorkflowInstance *WorkflowInstance      `protobuf:"bytes,1,opt,name=workflow_instance,json=workflowInstance,proto3" json:"workflow_instance,omitempty" toml:"workflow_instance,omitempty" mapstructure:"workflow_instance,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *ListWorkflowInstancesResponse) Reset() {
	*x = ListWorkflowInstancesResponse{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListWorkflowInstancesResponse) ProtoMessage() {}

func (x *ListWorkflowInstancesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[29]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListWorkflowInstancesResponse.ProtoReflect.Descriptor instead.
func (*ListWorkflowInstancesResponse) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{29}
}

func (x *ListWorkflowInstancesResponse) GetWorkflowInstance() *WorkflowInstance {
	if x != nil {
		return x.WorkflowInstance
	}
	return nil
}

type DequeueWorkflowRequest_Dequeue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	WorkflowNames []string               `protobuf:"bytes,2,rep,name=workflow_names,json=workflowNames,proto3" json:"workflow_names,omitempty" toml:"workflow_names,omitempty" mapstructure:"workflow_names,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowRequest_Dequeue) Reset() {
	*x = DequeueWorkflowRequest_Dequeue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowRequest_Dequeue) ProtoMessage() {}

func (x *DequeueWorkflowRequest_Dequeue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[30]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowRequest_Dequeue.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowRequest_Dequeue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{5, 0}
}

func (x *DequeueWorkflowRequest_Dequeue) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *DequeueWorkflowRequest_Dequeue) GetWorkflowNames() []string {
	if x != nil {
		return x.WorkflowNames
	}
	return nil
}

type DequeueWorkflowRequest_Continue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Payload       []byte                 `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty" toml:"payload,omitempty" mapstructure:"payload,omitempty"`
	Tasks         []*Task                `protobuf:"bytes,2,rep,name=tasks,proto3" json:"tasks,omitempty" toml:"tasks,omitempty" mapstructure:"tasks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowRequest_Continue) Reset() {
	*x = DequeueWorkflowRequest_Continue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowRequest_Continue) ProtoMessage() {}

func (x *DequeueWorkflowRequest_Continue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[31]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowRequest_Continue.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowRequest_Continue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{5, 1}
}

func (x *DequeueWorkflowRequest_Continue) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *DequeueWorkflowRequest_Continue) GetTasks() []*Task {
	if x != nil {
		return x.Tasks
	}
	return nil
}

type DequeueWorkflowRequest_Fail struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Err           string                 `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty" toml:"err,omitempty" mapstructure:"err,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowRequest_Fail) Reset() {
	*x = DequeueWorkflowRequest_Fail{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowRequest_Fail) ProtoMessage() {}

func (x *DequeueWorkflowRequest_Fail) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[32]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowRequest_Fail.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowRequest_Fail) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{5, 2}
}

func (x *DequeueWorkflowRequest_Fail) GetErr() string {
	if x != nil {
		return x.Err
	}
	return ""
}

type DequeueWorkflowRequest_Done struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Result        []byte                 `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" toml:"result,omitempty" mapstructure:"result,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowRequest_Done) Reset() {
	*x = DequeueWorkflowRequest_Done{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowRequest_Done) ProtoMessage() {}

func (x *DequeueWorkflowRequest_Done) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[33]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowRequest_Done.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowRequest_Done) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{5, 3}
}

func (x *DequeueWorkflowRequest_Done) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}

type DequeueWorkflowChunkRequest_Dequeue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	WorkflowNames []string               `protobuf:"bytes,2,rep,name=workflow_names,json=workflowNames,proto3" json:"workflow_names,omitempty" toml:"workflow_names,omitempty" mapstructure:"workflow_names,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowChunkRequest_Dequeue) Reset() {
	*x = DequeueWorkflowChunkRequest_Dequeue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowChunkRequest_Dequeue) ProtoMessage() {}

func (x *DequeueWorkflowChunkRequest_Dequeue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[34]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkRequest_Dequeue.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkRequest_Dequeue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{6, 0}
}

func (x *DequeueWorkflowChunkRequest_Dequeue) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *DequeueWorkflowChunkRequest_Dequeue) GetWorkflowNames() []string {
	if x != nil {
		return x.WorkflowNames
	}
	return nil
}

type DequeueWorkflowChunkRequest_Continue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Payload       []byte                 `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty" toml:"payload,omitempty" mapstructure:"payload,omitempty"`
	Tasks         []*Task                `protobuf:"bytes,2,rep,name=tasks,proto3" json:"tasks,omitempty" toml:"tasks,omitempty" mapstructure:"tasks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowChunkRequest_Continue) Reset() {
	*x = DequeueWorkflowChunkRequest_Continue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowChunkRequest_Continue) ProtoMessage() {}

func (x *DequeueWorkflowChunkRequest_Continue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[35]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkRequest_Continue.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkRequest_Continue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{6, 1}
}

func (x *DequeueWorkflowChunkRequest_Continue) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *DequeueWorkflowChunkRequest_Continue) GetTasks() []*Task {
	if x != nil {
		return x.Tasks
	}
	return nil
}

type DequeueWorkflowChunkRequest_Fail struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Err           string                 `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty" toml:"err,omitempty" mapstructure:"err,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowChunkRequest_Fail) Reset() {
	*x = DequeueWorkflowChunkRequest_Fail{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowChunkRequest_Fail) ProtoMessage() {}

func (x *DequeueWorkflowChunkRequest_Fail) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[36]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkRequest_Fail.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkRequest_Fail) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{6, 2}
}

func (x *DequeueWorkflowChunkRequest_Fail) GetErr() string {
	if x != nil {
		return x.Err
	}
	return ""
}

type DequeueWorkflowChunkRequest_Done struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Result        []byte                 `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" toml:"result,omitempty" mapstructure:"result,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowChunkRequest_Done) Reset() {
	*x = DequeueWorkflowChunkRequest_Done{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowChunkRequest_Done) ProtoMessage() {}

func (x *DequeueWorkflowChunkRequest_Done) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[37]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowChunkRequest_Done.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowChunkRequest_Done) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{6, 3}
}

func (x *DequeueWorkflowChunkRequest_Done) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}

type DequeueWorkflowResponse_Dequeue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Instance      *WorkflowInstance      `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty" toml:"instance,omitempty" mapstructure:"instance,omitempty"`
	Event         *WorkflowEvent         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty" toml:"event,omitempty" mapstructure:"event,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowResponse_Dequeue) Reset() {
	*x = DequeueWorkflowResponse_Dequeue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowResponse_Dequeue) ProtoMessage() {}

func (x *DequeueWorkflowResponse_Dequeue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[38]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowResponse_Dequeue.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowResponse_Dequeue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{7, 0}
}

func (x *DequeueWorkflowResponse_Dequeue) GetInstance() *WorkflowInstance {
	if x != nil {
		return x.Instance
	}
	return nil
}

func (x *DequeueWorkflowResponse_Dequeue) GetEvent() *WorkflowEvent {
	if x != nil {
		return x.Event
	}
	return nil
}

type DequeueWorkflowResponse_Status struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Err           string                 `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty" toml:"err,omitempty" mapstructure:"err,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueWorkflowResponse_Status) Reset() {
	*x = DequeueWorkflowResponse_Status{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowResponse_Status) ProtoMessage() {}

func (x *DequeueWorkflowResponse_Status) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[39]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowResponse_Status.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowResponse_Status) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{7, 1}
}

func (x *DequeueWorkflowResponse_Status) GetErr() string {
	if x != nil {
		return x.Err
	}
	return ""
}

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

func (x *DequeueWorkflowResponse_Committed) Reset() {
	*x = DequeueWorkflowResponse_Committed{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueWorkflowResponse_Committed) ProtoMessage() {}

func (x *DequeueWorkflowResponse_Committed) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[40]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueWorkflowResponse_Committed.ProtoReflect.Descriptor instead.
func (*DequeueWorkflowResponse_Committed) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{7, 2}
}

type DequeueTaskRequest_Dequeue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domain        string                 `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty" toml:"domain,omitempty" mapstructure:"domain,omitempty"`
	TaskName      string                 `protobuf:"bytes,2,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty" toml:"task_name,omitempty" mapstructure:"task_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskRequest_Dequeue) Reset() {
	*x = DequeueTaskRequest_Dequeue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskRequest_Dequeue) ProtoMessage() {}

func (x *DequeueTaskRequest_Dequeue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[41]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskRequest_Dequeue.ProtoReflect.Descriptor instead.
func (*DequeueTaskRequest_Dequeue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{15, 0}
}

func (x *DequeueTaskRequest_Dequeue) GetDomain() string {
	if x != nil {
		return x.Domain
	}
	return ""
}

func (x *DequeueTaskRequest_Dequeue) GetTaskName() string {
	if x != nil {
		return x.TaskName
	}
	return ""
}

type DequeueTaskRequest_Fail struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Error         string                 `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" toml:"error,omitempty" mapstructure:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskRequest_Fail) Reset() {
	*x = DequeueTaskRequest_Fail{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskRequest_Fail) ProtoMessage() {}

func (x *DequeueTaskRequest_Fail) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[42]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskRequest_Fail.ProtoReflect.Descriptor instead.
func (*DequeueTaskRequest_Fail) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{15, 1}
}

func (x *DequeueTaskRequest_Fail) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

type DequeueTaskRequest_Succeed struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Result        []byte                 `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" toml:"result,omitempty" mapstructure:"result,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskRequest_Succeed) Reset() {
	*x = DequeueTaskRequest_Succeed{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskRequest_Succeed) ProtoMessage() {}

func (x *DequeueTaskRequest_Succeed) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[43]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskRequest_Succeed.ProtoReflect.Descriptor instead.
func (*DequeueTaskRequest_Succeed) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{15, 2}
}

func (x *DequeueTaskRequest_Succeed) GetResult() []byte {
	if x != nil {
		return x.Result
	}
	return nil
}

type DequeueTaskResponse_Dequeue struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Task          *Task                  `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty" toml:"task,omitempty" mapstructure:"task,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskResponse_Dequeue) Reset() {
	*x = DequeueTaskResponse_Dequeue{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskResponse_Dequeue) ProtoMessage() {}

func (x *DequeueTaskResponse_Dequeue) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[44]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskResponse_Dequeue.ProtoReflect.Descriptor instead.
func (*DequeueTaskResponse_Dequeue) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{16, 0}
}

func (x *DequeueTaskResponse_Dequeue) GetTask() *Task {
	if x != nil {
		return x.Task
	}
	return nil
}

type DequeueTaskResponse_Cancel struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Err           string                 `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty" toml:"err,omitempty" mapstructure:"err,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DequeueTaskResponse_Cancel) Reset() {
	*x = DequeueTaskResponse_Cancel{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskResponse_Cancel) ProtoMessage() {}

func (x *DequeueTaskResponse_Cancel) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[45]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskResponse_Cancel.ProtoReflect.Descriptor instead.
func (*DequeueTaskResponse_Cancel) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{16, 1}
}

func (x *DequeueTaskResponse_Cancel) GetErr() string {
	if x != nil {
		return x.Err
	}
	return ""
}

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

func (x *DequeueTaskResponse_Committed) Reset() {
	*x = DequeueTaskResponse_Committed{}
	mi := &file_interservice_cereal_cereal_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DequeueTaskResponse_Committed) ProtoMessage() {}

func (x *DequeueTaskResponse_Committed) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_cereal_cereal_proto_msgTypes[46]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DequeueTaskResponse_Committed.ProtoReflect.Descriptor instead.
func (*DequeueTaskResponse_Committed) Descriptor() ([]byte, []int) {
	return file_interservice_cereal_cereal_proto_rawDescGZIP(), []int{16, 2}
}

var File_interservice_cereal_cereal_proto protoreflect.FileDescriptor

const file_interservice_cereal_cereal_proto_rawDesc = "" +
	"\n" +
	" interservice/cereal/cereal.proto\x12\x1achef.automate.infra.cereal\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\xbd\x01\n" +
	"\x04Task\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1e\n" +
	"\n" +
	"parameters\x18\x02 \x01(\fR\n" +
	"parameters\x12;\n" +
	"\vstart_after\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"startAfter\x12D\n" +
	"\bmetadata\x18\x04 \x01(\v2(.chef.automate.infra.cereal.TaskMetadataR\bmetadata\"K\n" +
	"\fTaskMetadata\x12;\n" +
	"\venqueued_at\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"enqueuedAt\"\xf0\x01\n" +
	"\x10WorkflowInstance\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x12\x16\n" +
	"\x06status\x18\x04 \x01(\tR\x06status\x12\x1e\n" +
	"\n" +
	"parameters\x18\x05 \x01(\fR\n" +
	"parameters\x12\x18\n" +
	"\apayload\x18\x06 \x01(\fR\apayload\x12\x16\n" +
	"\x06result\x18\a \x01(\fR\x06result\x12\x10\n" +
	"\x03err\x18\b \x01(\tR\x03err\"\x98\x01\n" +
	"\n" +
	"TaskResult\x12\x1b\n" +
	"\ttask_name\x18\x01 \x01(\tR\btaskName\x12\x1e\n" +
	"\n" +
	"parameters\x18\x02 \x01(\fR\n" +
	"parameters\x12\x16\n" +
	"\x06status\x18\x03 \x01(\tR\x06status\x12\x1d\n" +
	"\n" +
	"error_text\x18\x04 \x01(\tR\terrorText\x12\x16\n" +
	"\x06result\x18\x05 \x01(\fR\x06result\"\x8b\x02\n" +
	"\rWorkflowEvent\x12\x12\n" +
	"\x04type\x18\x01 \x01(\tR\x04type\x12.\n" +
	"\x13enqueued_task_count\x18\x02 \x01(\x03R\x11enqueuedTaskCount\x120\n" +
	"\x14completed_task_count\x18\x03 \x01(\x03R\x12completedTaskCount\x12G\n" +
	"\vtask_result\x18\x04 \x01(\v2&.chef.automate.infra.cereal.TaskResultR\n" +
	"taskResult\x12;\n" +
	"\venqueued_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"enqueuedAt\"\xd2\x04\n" +
	"\x16DequeueWorkflowRequest\x12V\n" +
	"\adequeue\x18\x01 \x01(\v2:.chef.automate.infra.cereal.DequeueWorkflowRequest.DequeueH\x00R\adequeue\x12Y\n" +
	"\bcontinue\x18\x02 \x01(\v2;.chef.automate.infra.cereal.DequeueWorkflowRequest.ContinueH\x00R\bcontinue\x12M\n" +
	"\x04done\x18\x03 \x01(\v27.chef.automate.infra.cereal.DequeueWorkflowRequest.DoneH\x00R\x04done\x12M\n" +
	"\x04fail\x18\x04 \x01(\v27.chef.automate.infra.cereal.DequeueWorkflowRequest.FailH\x00R\x04fail\x1aH\n" +
	"\aDequeue\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12%\n" +
	"\x0eworkflow_names\x18\x02 \x03(\tR\rworkflowNames\x1a\\\n" +
	"\bContinue\x12\x18\n" +
	"\apayload\x18\x01 \x01(\fR\apayload\x126\n" +
	"\x05tasks\x18\x02 \x03(\v2 .chef.automate.infra.cereal.TaskR\x05tasks\x1a\x18\n" +
	"\x04Fail\x12\x10\n" +
	"\x03err\x18\x01 \x01(\tR\x03err\x1a\x1e\n" +
	"\x04Done\x12\x16\n" +
	"\x06result\x18\x01 \x01(\fR\x06resultB\x05\n" +
	"\x03cmd\"\xeb\x04\n" +
	"\x1bDequeueWorkflowChunkRequest\x12[\n" +
	"\adequeue\x18\x01 \x01(\v2?.chef.automate.infra.cereal.DequeueWorkflowChunkRequest.DequeueH\x00R\adequeue\x12^\n" +
	"\bcontinue\x18\x02 \x01(\v2@.chef.automate.infra.cereal.DequeueWorkflowChunkRequest.ContinueH\x00R\bcontinue\x12R\n" +
	"\x04done\x18\x03 \x01(\v2<.chef.automate.infra.cereal.DequeueWorkflowChunkRequest.DoneH\x00R\x04done\x12R\n" +
	"\x04fail\x18\x04 \x01(\v2<.chef.automate.infra.cereal.DequeueWorkflowChunkRequest.FailH\x00R\x04fail\x1aH\n" +
	"\aDequeue\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12%\n" +
	"\x0eworkflow_names\x18\x02 \x03(\tR\rworkflowNames\x1a\\\n" +
	"\bContinue\x12\x18\n" +
	"\apayload\x18\x01 \x01(\fR\apayload\x126\n" +
	"\x05tasks\x18\x02 \x03(\v2 .chef.automate.infra.cereal.TaskR\x05tasks\x1a\x18\n" +
	"\x04Fail\x12\x10\n" +
	"\x03err\x18\x01 \x01(\tR\x03err\x1a\x1e\n" +
	"\x04Done\x12\x16\n" +
	"\x06result\x18\x01 \x01(\fR\x06resultB\x05\n" +
	"\x03cmd\"\xee\x03\n" +
	"\x17DequeueWorkflowResponse\x12W\n" +
	"\adequeue\x18\x01 \x01(\v2;.chef.automate.infra.cereal.DequeueWorkflowResponse.DequeueH\x00R\adequeue\x12T\n" +
	"\x06status\x18\x02 \x01(\v2:.chef.automate.infra.cereal.DequeueWorkflowResponse.StatusH\x00R\x06status\x12]\n" +
	"\tcommitted\x18\x03 \x01(\v2=.chef.automate.infra.cereal.DequeueWorkflowResponse.CommittedH\x00R\tcommitted\x1a\x94\x01\n" +
	"\aDequeue\x12H\n" +
	"\binstance\x18\x01 \x01(\v2,.chef.automate.infra.cereal.WorkflowInstanceR\binstance\x12?\n" +
	"\x05event\x18\x02 \x01(\v2).chef.automate.infra.cereal.WorkflowEventR\x05event\x1a\x1a\n" +
	"\x06Status\x12\x10\n" +
	"\x03err\x18\x01 \x01(\tR\x03err\x1a\v\n" +
	"\tCommittedB\x05\n" +
	"\x03cmd\"4\n" +
	"\x1cDequeueWorkflowChunkResponse\x12\x14\n" +
	"\x05chunk\x18\x01 \x01(\fR\x05chunk\"\x9a\x01\n" +
	"\x16EnqueueWorkflowRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x12\x1e\n" +
	"\n" +
	"parameters\x18\x04 \x01(\fR\n" +
	"parameters\"\x19\n" +
	"\x17EnqueueWorkflowResponse\"y\n" +
	"\x15CancelWorkflowRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\"\x18\n" +
	"\x16CancelWorkflowResponse\"w\n" +
	"\x13KillWorkflowRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\"\x16\n" +
	"\x14KillWorkflowResponse\"\x8f\x03\n" +
	"\x12DequeueTaskRequest\x12R\n" +
	"\adequeue\x18\x01 \x01(\v26.chef.automate.infra.cereal.DequeueTaskRequest.DequeueH\x00R\adequeue\x12R\n" +
	"\asucceed\x18\x02 \x01(\v26.chef.automate.infra.cereal.DequeueTaskRequest.SucceedH\x00R\asucceed\x12I\n" +
	"\x04fail\x18\x03 \x01(\v23.chef.automate.infra.cereal.DequeueTaskRequest.FailH\x00R\x04fail\x1a>\n" +
	"\aDequeue\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12\x1b\n" +
	"\ttask_name\x18\x02 \x01(\tR\btaskName\x1a\x1c\n" +
	"\x04Fail\x12\x14\n" +
	"\x05error\x18\x01 \x01(\tR\x05error\x1a!\n" +
	"\aSucceed\x12\x16\n" +
	"\x06result\x18\x01 \x01(\fR\x06resultB\x05\n" +
	"\x03cmd\"\x88\x03\n" +
	"\x13DequeueTaskResponse\x12S\n" +
	"\adequeue\x18\x01 \x01(\v27.chef.automate.infra.cereal.DequeueTaskResponse.DequeueH\x00R\adequeue\x12P\n" +
	"\x06cancel\x18\x02 \x01(\v26.chef.automate.infra.cereal.DequeueTaskResponse.CancelH\x00R\x06cancel\x12Y\n" +
	"\tcommitted\x18\x03 \x01(\v29.chef.automate.infra.cereal.DequeueTaskResponse.CommittedH\x00R\tcommitted\x1a?\n" +
	"\aDequeue\x124\n" +
	"\x04task\x18\x01 \x01(\v2 .chef.automate.infra.cereal.TaskR\x04task\x1a\x1a\n" +
	"\x06Cancel\x12\x10\n" +
	"\x03err\x18\x01 \x01(\tR\x03err\x1a\v\n" +
	"\tCommittedB\x05\n" +
	"\x03cmd\"\xb1\x02\n" +
	"\x1dCreateWorkflowScheduleRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x12\x1e\n" +
	"\n" +
	"parameters\x18\x04 \x01(\fR\n" +
	"parameters\x12\x18\n" +
	"\aenabled\x18\x05 \x01(\bR\aenabled\x12\x1e\n" +
	"\n" +
	"recurrence\x18\x06 \x01(\tR\n" +
	"recurrence\x12\x18\n" +
	"\apayload\x18\a \x01(\fR\apayload\x12:\n" +
	"\vnext_run_at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\tnextRunAt\" \n" +
	"\x1eCreateWorkflowScheduleResponse\"6\n" +
	"\x1cListWorkflowSchedulesRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\"\xba\x03\n" +
	"\bSchedule\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x12\x1e\n" +
	"\n" +
	"parameters\x18\x04 \x01(\fR\n" +
	"parameters\x12\x1e\n" +
	"\n" +
	"recurrence\x18\x05 \x01(\tR\n" +
	"recurrence\x12:\n" +
	"\vnext_due_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tnextDueAt\x12D\n" +
	"\x10last_enqueued_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\x0elastEnqueuedAt\x12\x18\n" +
	"\aenabled\x18\b \x01(\bR\aenabled\x129\n" +
	"\n" +
	"last_start\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\tlastStart\x125\n" +
	"\blast_end\x18\n" +
	" \x01(\v2\x1a.google.protobuf.TimestampR\alastEnd\"\x86\x01\n" +
	"\x1dListWorkflowSchedulesResponse\x12#\n" +
	"\rnum_schedules\x18\x01 \x01(\x05R\fnumSchedules\x12@\n" +
	"\bschedule\x18\x02 \x01(\v2$.chef.automate.infra.cereal.ScheduleR\bschedule\"\x84\x01\n" +
	" GetWorkflowScheduleByNameRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\"e\n" +
	"!GetWorkflowScheduleByNameResponse\x12@\n" +
	"\bschedule\x18\x01 \x01(\v2$.chef.automate.infra.cereal.ScheduleR\bschedule\"\xf4\x02\n" +
	"#UpdateWorkflowScheduleByNameRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x124\n" +
	"\aenabled\x18\x04 \x01(\v2\x1a.google.protobuf.BoolValueR\aenabled\x12;\n" +
	"\n" +
	"parameters\x18\x05 \x01(\v2\x1b.google.protobuf.BytesValueR\n" +
	"parameters\x12<\n" +
	"\n" +
	"recurrence\x18\x06 \x01(\v2\x1c.google.protobuf.StringValueR\n" +
	"recurrence\x12:\n" +
	"\vnext_run_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\tnextRunAt\"&\n" +
	"$UpdateWorkflowScheduleByNameResponse\"\x84\x01\n" +
	" GetWorkflowInstanceByNameRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12#\n" +
	"\rinstance_name\x18\x02 \x01(\tR\finstanceName\x12#\n" +
	"\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\"~\n" +
	"!GetWorkflowInstanceByNameResponse\x12Y\n" +
	"\x11workflow_instance\x18\x01 \x01(\v2,.chef.automate.infra.cereal.WorkflowInstanceR\x10workflowInstance\"\xf7\x01\n" +
	"\x1cListWorkflowInstancesRequest\x12\x16\n" +
	"\x06domain\x18\x01 \x01(\tR\x06domain\x12A\n" +
	"\rworkflow_name\x18\x02 \x01(\v2\x1c.google.protobuf.StringValueR\fworkflowName\x12A\n" +
	"\rinstance_name\x18\x03 \x01(\v2\x1c.google.protobuf.StringValueR\finstanceName\x129\n" +
	"\n" +
	"is_running\x18\x04 \x01(\v2\x1a.google.protobuf.BoolValueR\tisRunning\"z\n" +
	"\x1dListWorkflowInstancesResponse\x12Y\n" +
	"\x11workflow_instance\x18\x01 \x01(\v2,.chef.automate.infra.cereal.WorkflowInstanceR\x10workflowInstance2\x89\r\n" +
	"\rCerealService\x12z\n" +
	"\x0fEnqueueWorkflow\x122.chef.automate.infra.cereal.EnqueueWorkflowRequest\x1a3.chef.automate.infra.cereal.EnqueueWorkflowResponse\x12~\n" +
	"\x0fDequeueWorkflow\x122.chef.automate.infra.cereal.DequeueWorkflowRequest\x1a3.chef.automate.infra.cereal.DequeueWorkflowResponse(\x010\x01\x12\x8d\x01\n" +
	"\x14DequeueWorkflowChunk\x127.chef.automate.infra.cereal.DequeueWorkflowChunkRequest\x1a8.chef.automate.infra.cereal.DequeueWorkflowChunkResponse(\x010\x01\x12w\n" +
	"\x0eCancelWorkflow\x121.chef.automate.infra.cereal.CancelWorkflowRequest\x1a2.chef.automate.infra.cereal.CancelWorkflowResponse\x12q\n" +
	"\fKillWorkflow\x12/.chef.automate.infra.cereal.KillWorkflowRequest\x1a0.chef.automate.infra.cereal.KillWorkflowResponse\x12r\n" +
	"\vDequeueTask\x12..chef.automate.infra.cereal.DequeueTaskRequest\x1a/.chef.automate.infra.cereal.DequeueTaskResponse(\x010\x01\x12\x8f\x01\n" +
	"\x16CreateWorkflowSchedule\x129.chef.automate.infra.cereal.CreateWorkflowScheduleRequest\x1a:.chef.automate.infra.cereal.CreateWorkflowScheduleResponse\x12\x8e\x01\n" +
	"\x15ListWorkflowSchedules\x128.chef.automate.infra.cereal.ListWorkflowSchedulesRequest\x1a9.chef.automate.infra.cereal.ListWorkflowSchedulesResponse0\x01\x12\x98\x01\n" +
	"\x19GetWorkflowScheduleByName\x12<.chef.automate.infra.cereal.GetWorkflowScheduleByNameRequest\x1a=.chef.automate.infra.cereal.GetWorkflowScheduleByNameResponse\x12\xa1\x01\n" +
	"\x1cUpdateWorkflowScheduleByName\x12?.chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest\x1a@.chef.automate.infra.cereal.UpdateWorkflowScheduleByNameResponse\x12\x98\x01\n" +
	"\x19GetWorkflowInstanceByName\x12<.chef.automate.infra.cereal.GetWorkflowInstanceByNameRequest\x1a=.chef.automate.infra.cereal.GetWorkflowInstanceByNameResponse\x12\x8e\x01\n" +
	"\x15ListWorkflowInstances\x128.chef.automate.infra.cereal.ListWorkflowInstancesRequest\x1a9.chef.automate.infra.cereal.ListWorkflowInstancesResponse0\x01B2Z0github.com/chef/automate/api/interservice/cerealb\x06proto3"

var (
	file_interservice_cereal_cereal_proto_rawDescOnce sync.Once
	file_interservice_cereal_cereal_proto_rawDescData []byte
)

func file_interservice_cereal_cereal_proto_rawDescGZIP() []byte {
	file_interservice_cereal_cereal_proto_rawDescOnce.Do(func() {
		file_interservice_cereal_cereal_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_interservice_cereal_cereal_proto_rawDesc), len(file_interservice_cereal_cereal_proto_rawDesc)))
	})
	return file_interservice_cereal_cereal_proto_rawDescData
}

var file_interservice_cereal_cereal_proto_msgTypes = make([]protoimpl.MessageInfo, 47)
var file_interservice_cereal_cereal_proto_goTypes = []any{
	(*Task)(nil),                                 // 0: chef.automate.infra.cereal.Task
	(*TaskMetadata)(nil),                         // 1: chef.automate.infra.cereal.TaskMetadata
	(*WorkflowInstance)(nil),                     // 2: chef.automate.infra.cereal.WorkflowInstance
	(*TaskResult)(nil),                           // 3: chef.automate.infra.cereal.TaskResult
	(*WorkflowEvent)(nil),                        // 4: chef.automate.infra.cereal.WorkflowEvent
	(*DequeueWorkflowRequest)(nil),               // 5: chef.automate.infra.cereal.DequeueWorkflowRequest
	(*DequeueWorkflowChunkRequest)(nil),          // 6: chef.automate.infra.cereal.DequeueWorkflowChunkRequest
	(*DequeueWorkflowResponse)(nil),              // 7: chef.automate.infra.cereal.DequeueWorkflowResponse
	(*DequeueWorkflowChunkResponse)(nil),         // 8: chef.automate.infra.cereal.DequeueWorkflowChunkResponse
	(*EnqueueWorkflowRequest)(nil),               // 9: chef.automate.infra.cereal.EnqueueWorkflowRequest
	(*EnqueueWorkflowResponse)(nil),              // 10: chef.automate.infra.cereal.EnqueueWorkflowResponse
	(*CancelWorkflowRequest)(nil),                // 11: chef.automate.infra.cereal.CancelWorkflowRequest
	(*CancelWorkflowResponse)(nil),               // 12: chef.automate.infra.cereal.CancelWorkflowResponse
	(*KillWorkflowRequest)(nil),                  // 13: chef.automate.infra.cereal.KillWorkflowRequest
	(*KillWorkflowResponse)(nil),                 // 14: chef.automate.infra.cereal.KillWorkflowResponse
	(*DequeueTaskRequest)(nil),                   // 15: chef.automate.infra.cereal.DequeueTaskRequest
	(*DequeueTaskResponse)(nil),                  // 16: chef.automate.infra.cereal.DequeueTaskResponse
	(*CreateWorkflowScheduleRequest)(nil),        // 17: chef.automate.infra.cereal.CreateWorkflowScheduleRequest
	(*CreateWorkflowScheduleResponse)(nil),       // 18: chef.automate.infra.cereal.CreateWorkflowScheduleResponse
	(*ListWorkflowSchedulesRequest)(nil),         // 19: chef.automate.infra.cereal.ListWorkflowSchedulesRequest
	(*Schedule)(nil),                             // 20: chef.automate.infra.cereal.Schedule
	(*ListWorkflowSchedulesResponse)(nil),        // 21: chef.automate.infra.cereal.ListWorkflowSchedulesResponse
	(*GetWorkflowScheduleByNameRequest)(nil),     // 22: chef.automate.infra.cereal.GetWorkflowScheduleByNameRequest
	(*GetWorkflowScheduleByNameResponse)(nil),    // 23: chef.automate.infra.cereal.GetWorkflowScheduleByNameResponse
	(*UpdateWorkflowScheduleByNameRequest)(nil),  // 24: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest
	(*UpdateWorkflowScheduleByNameResponse)(nil), // 25: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameResponse
	(*GetWorkflowInstanceByNameRequest)(nil),     // 26: chef.automate.infra.cereal.GetWorkflowInstanceByNameRequest
	(*GetWorkflowInstanceByNameResponse)(nil),    // 27: chef.automate.infra.cereal.GetWorkflowInstanceByNameResponse
	(*ListWorkflowInstancesRequest)(nil),         // 28: chef.automate.infra.cereal.ListWorkflowInstancesRequest
	(*ListWorkflowInstancesResponse)(nil),        // 29: chef.automate.infra.cereal.ListWorkflowInstancesResponse
	(*DequeueWorkflowRequest_Dequeue)(nil),       // 30: chef.automate.infra.cereal.DequeueWorkflowRequest.Dequeue
	(*DequeueWorkflowRequest_Continue)(nil),      // 31: chef.automate.infra.cereal.DequeueWorkflowRequest.Continue
	(*DequeueWorkflowRequest_Fail)(nil),          // 32: chef.automate.infra.cereal.DequeueWorkflowRequest.Fail
	(*DequeueWorkflowRequest_Done)(nil),          // 33: chef.automate.infra.cereal.DequeueWorkflowRequest.Done
	(*DequeueWorkflowChunkRequest_Dequeue)(nil),  // 34: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Dequeue
	(*DequeueWorkflowChunkRequest_Continue)(nil), // 35: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Continue
	(*DequeueWorkflowChunkRequest_Fail)(nil),     // 36: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Fail
	(*DequeueWorkflowChunkRequest_Done)(nil),     // 37: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Done
	(*DequeueWorkflowResponse_Dequeue)(nil),      // 38: chef.automate.infra.cereal.DequeueWorkflowResponse.Dequeue
	(*DequeueWorkflowResponse_Status)(nil),       // 39: chef.automate.infra.cereal.DequeueWorkflowResponse.Status
	(*DequeueWorkflowResponse_Committed)(nil),    // 40: chef.automate.infra.cereal.DequeueWorkflowResponse.Committed
	(*DequeueTaskRequest_Dequeue)(nil),           // 41: chef.automate.infra.cereal.DequeueTaskRequest.Dequeue
	(*DequeueTaskRequest_Fail)(nil),              // 42: chef.automate.infra.cereal.DequeueTaskRequest.Fail
	(*DequeueTaskRequest_Succeed)(nil),           // 43: chef.automate.infra.cereal.DequeueTaskRequest.Succeed
	(*DequeueTaskResponse_Dequeue)(nil),          // 44: chef.automate.infra.cereal.DequeueTaskResponse.Dequeue
	(*DequeueTaskResponse_Cancel)(nil),           // 45: chef.automate.infra.cereal.DequeueTaskResponse.Cancel
	(*DequeueTaskResponse_Committed)(nil),        // 46: chef.automate.infra.cereal.DequeueTaskResponse.Committed
	(*timestamppb.Timestamp)(nil),                // 47: google.protobuf.Timestamp
	(*wrapperspb.BoolValue)(nil),                 // 48: google.protobuf.BoolValue
	(*wrapperspb.BytesValue)(nil),                // 49: google.protobuf.BytesValue
	(*wrapperspb.StringValue)(nil),               // 50: google.protobuf.StringValue
}
var file_interservice_cereal_cereal_proto_depIdxs = []int32{
	47, // 0: chef.automate.infra.cereal.Task.start_after:type_name -> google.protobuf.Timestamp
	1,  // 1: chef.automate.infra.cereal.Task.metadata:type_name -> chef.automate.infra.cereal.TaskMetadata
	47, // 2: chef.automate.infra.cereal.TaskMetadata.enqueued_at:type_name -> google.protobuf.Timestamp
	3,  // 3: chef.automate.infra.cereal.WorkflowEvent.task_result:type_name -> chef.automate.infra.cereal.TaskResult
	47, // 4: chef.automate.infra.cereal.WorkflowEvent.enqueued_at:type_name -> google.protobuf.Timestamp
	30, // 5: chef.automate.infra.cereal.DequeueWorkflowRequest.dequeue:type_name -> chef.automate.infra.cereal.DequeueWorkflowRequest.Dequeue
	31, // 6: chef.automate.infra.cereal.DequeueWorkflowRequest.continue:type_name -> chef.automate.infra.cereal.DequeueWorkflowRequest.Continue
	33, // 7: chef.automate.infra.cereal.DequeueWorkflowRequest.done:type_name -> chef.automate.infra.cereal.DequeueWorkflowRequest.Done
	32, // 8: chef.automate.infra.cereal.DequeueWorkflowRequest.fail:type_name -> chef.automate.infra.cereal.DequeueWorkflowRequest.Fail
	34, // 9: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.dequeue:type_name -> chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Dequeue
	35, // 10: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.continue:type_name -> chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Continue
	37, // 11: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.done:type_name -> chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Done
	36, // 12: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.fail:type_name -> chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Fail
	38, // 13: chef.automate.infra.cereal.DequeueWorkflowResponse.dequeue:type_name -> chef.automate.infra.cereal.DequeueWorkflowResponse.Dequeue
	39, // 14: chef.automate.infra.cereal.DequeueWorkflowResponse.status:type_name -> chef.automate.infra.cereal.DequeueWorkflowResponse.Status
	40, // 15: chef.automate.infra.cereal.DequeueWorkflowResponse.committed:type_name -> chef.automate.infra.cereal.DequeueWorkflowResponse.Committed
	41, // 16: chef.automate.infra.cereal.DequeueTaskRequest.dequeue:type_name -> chef.automate.infra.cereal.DequeueTaskRequest.Dequeue
	43, // 17: chef.automate.infra.cereal.DequeueTaskRequest.succeed:type_name -> chef.automate.infra.cereal.DequeueTaskRequest.Succeed
	42, // 18: chef.automate.infra.cereal.DequeueTaskRequest.fail:type_name -> chef.automate.infra.cereal.DequeueTaskRequest.Fail
	44, // 19: chef.automate.infra.cereal.DequeueTaskResponse.dequeue:type_name -> chef.automate.infra.cereal.DequeueTaskResponse.Dequeue
	45, // 20: chef.automate.infra.cereal.DequeueTaskResponse.cancel:type_name -> chef.automate.infra.cereal.DequeueTaskResponse.Cancel
	46, // 21: chef.automate.infra.cereal.DequeueTaskResponse.committed:type_name -> chef.automate.infra.cereal.DequeueTaskResponse.Committed
	47, // 22: chef.automate.infra.cereal.CreateWorkflowScheduleRequest.next_run_at:type_name -> google.protobuf.Timestamp
	47, // 23: chef.automate.infra.cereal.Schedule.next_due_at:type_name -> google.protobuf.Timestamp
	47, // 24: chef.automate.infra.cereal.Schedule.last_enqueued_at:type_name -> google.protobuf.Timestamp
	47, // 25: chef.automate.infra.cereal.Schedule.last_start:type_name -> google.protobuf.Timestamp
	47, // 26: chef.automate.infra.cereal.Schedule.last_end:type_name -> google.protobuf.Timestamp
	20, // 27: chef.automate.infra.cereal.ListWorkflowSchedulesResponse.schedule:type_name -> chef.automate.infra.cereal.Schedule
	20, // 28: chef.automate.infra.cereal.GetWorkflowScheduleByNameResponse.schedule:type_name -> chef.automate.infra.cereal.Schedule
	48, // 29: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest.enabled:type_name -> google.protobuf.BoolValue
	49, // 30: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest.parameters:type_name -> google.protobuf.BytesValue
	50, // 31: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest.recurrence:type_name -> google.protobuf.StringValue
	47, // 32: chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest.next_run_at:type_name -> google.protobuf.Timestamp
	2,  // 33: chef.automate.infra.cereal.GetWorkflowInstanceByNameResponse.workflow_instance:type_name -> chef.automate.infra.cereal.WorkflowInstance
	50, // 34: chef.automate.infra.cereal.ListWorkflowInstancesRequest.workflow_name:type_name -> google.protobuf.StringValue
	50, // 35: chef.automate.infra.cereal.ListWorkflowInstancesRequest.instance_name:type_name -> google.protobuf.StringValue
	48, // 36: chef.automate.infra.cereal.ListWorkflowInstancesRequest.is_running:type_name -> google.protobuf.BoolValue
	2,  // 37: chef.automate.infra.cereal.ListWorkflowInstancesResponse.workflow_instance:type_name -> chef.automate.infra.cereal.WorkflowInstance
	0,  // 38: chef.automate.infra.cereal.DequeueWorkflowRequest.Continue.tasks:type_name -> chef.automate.infra.cereal.Task
	0,  // 39: chef.automate.infra.cereal.DequeueWorkflowChunkRequest.Continue.tasks:type_name -> chef.automate.infra.cereal.Task
	2,  // 40: chef.automate.infra.cereal.DequeueWorkflowResponse.Dequeue.instance:type_name -> chef.automate.infra.cereal.WorkflowInstance
	4,  // 41: chef.automate.infra.cereal.DequeueWorkflowResponse.Dequeue.event:type_name -> chef.automate.infra.cereal.WorkflowEvent
	0,  // 42: chef.automate.infra.cereal.DequeueTaskResponse.Dequeue.task:type_name -> chef.automate.infra.cereal.Task
	9,  // 43: chef.automate.infra.cereal.CerealService.EnqueueWorkflow:input_type -> chef.automate.infra.cereal.EnqueueWorkflowRequest
	5,  // 44: chef.automate.infra.cereal.CerealService.DequeueWorkflow:input_type -> chef.automate.infra.cereal.DequeueWorkflowRequest
	6,  // 45: chef.automate.infra.cereal.CerealService.DequeueWorkflowChunk:input_type -> chef.automate.infra.cereal.DequeueWorkflowChunkRequest
	11, // 46: chef.automate.infra.cereal.CerealService.CancelWorkflow:input_type -> chef.automate.infra.cereal.CancelWorkflowRequest
	13, // 47: chef.automate.infra.cereal.CerealService.KillWorkflow:input_type -> chef.automate.infra.cereal.KillWorkflowRequest
	15, // 48: chef.automate.infra.cereal.CerealService.DequeueTask:input_type -> chef.automate.infra.cereal.DequeueTaskRequest
	17, // 49: chef.automate.infra.cereal.CerealService.CreateWorkflowSchedule:input_type -> chef.automate.infra.cereal.CreateWorkflowScheduleRequest
	19, // 50: chef.automate.infra.cereal.CerealService.ListWorkflowSchedules:input_type -> chef.automate.infra.cereal.ListWorkflowSchedulesRequest
	22, // 51: chef.automate.infra.cereal.CerealService.GetWorkflowScheduleByName:input_type -> chef.automate.infra.cereal.GetWorkflowScheduleByNameRequest
	24, // 52: chef.automate.infra.cereal.CerealService.UpdateWorkflowScheduleByName:input_type -> chef.automate.infra.cereal.UpdateWorkflowScheduleByNameRequest
	26, // 53: chef.automate.infra.cereal.CerealService.GetWorkflowInstanceByName:input_type -> chef.automate.infra.cereal.GetWorkflowInstanceByNameRequest
	28, // 54: chef.automate.infra.cereal.CerealService.ListWorkflowInstances:input_type -> chef.automate.infra.cereal.ListWorkflowInstancesRequest
	10, // 55: chef.automate.infra.cereal.CerealService.EnqueueWorkflow:output_type -> chef.automate.infra.cereal.EnqueueWorkflowResponse
	7,  // 56: chef.automate.infra.cereal.CerealService.DequeueWorkflow:output_type -> chef.automate.infra.cereal.DequeueWorkflowResponse
	8,  // 57: chef.automate.infra.cereal.CerealService.DequeueWorkflowChunk:output_type -> chef.automate.infra.cereal.DequeueWorkflowChunkResponse
	12, // 58: chef.automate.infra.cereal.CerealService.CancelWorkflow:output_type -> chef.automate.infra.cereal.CancelWorkflowResponse
	14, // 59: chef.automate.infra.cereal.CerealService.KillWorkflow:output_type -> chef.automate.infra.cereal.KillWorkflowResponse
	16, // 60: chef.automate.infra.cereal.CerealService.DequeueTask:output_type -> chef.automate.infra.cereal.DequeueTaskResponse
	18, // 61: chef.automate.infra.cereal.CerealService.CreateWorkflowSchedule:output_type -> chef.automate.infra.cereal.CreateWorkflowScheduleResponse
	21, // 62: chef.automate.infra.cereal.CerealService.ListWorkflowSchedules:output_type -> chef.automate.infra.cereal.ListWorkflowSchedulesResponse
	23, // 63: chef.automate.infra.cereal.CerealService.GetWorkflowScheduleByName:output_type -> chef.automate.infra.cereal.GetWorkflowScheduleByNameResponse
	25, // 64: chef.automate.infra.cereal.CerealService.UpdateWorkflowScheduleByName:output_type -> chef.automate.infra.cereal.UpdateWorkflowScheduleByNameResponse
	27, // 65: chef.automate.infra.cereal.CerealService.GetWorkflowInstanceByName:output_type -> chef.automate.infra.cereal.GetWorkflowInstanceByNameResponse
	29, // 66: chef.automate.infra.cereal.CerealService.ListWorkflowInstances:output_type -> chef.automate.infra.cereal.ListWorkflowInstancesResponse
	55, // [55:67] is the sub-list for method output_type
	43, // [43:55] is the sub-list for method input_type
	43, // [43:43] is the sub-list for extension type_name
	43, // [43:43] is the sub-list for extension extendee
	0,  // [0:43] is the sub-list for field type_name
}

func init() { file_interservice_cereal_cereal_proto_init() }
func file_interservice_cereal_cereal_proto_init() {
	if File_interservice_cereal_cereal_proto != nil {
		return
	}
	file_interservice_cereal_cereal_proto_msgTypes[5].OneofWrappers = []any{
		(*DequeueWorkflowRequest_Dequeue_)(nil),
		(*DequeueWorkflowRequest_Continue_)(nil),
		(*DequeueWorkflowRequest_Done_)(nil),
		(*DequeueWorkflowRequest_Fail_)(nil),
	}
	file_interservice_cereal_cereal_proto_msgTypes[6].OneofWrappers = []any{
		(*DequeueWorkflowChunkRequest_Dequeue_)(nil),
		(*DequeueWorkflowChunkRequest_Continue_)(nil),
		(*DequeueWorkflowChunkRequest_Done_)(nil),
		(*DequeueWorkflowChunkRequest_Fail_)(nil),
	}
	file_interservice_cereal_cereal_proto_msgTypes[7].OneofWrappers = []any{
		(*DequeueWorkflowResponse_Dequeue_)(nil),
		(*DequeueWorkflowResponse_Status_)(nil),
		(*DequeueWorkflowResponse_Committed_)(nil),
	}
	file_interservice_cereal_cereal_proto_msgTypes[15].OneofWrappers = []any{
		(*DequeueTaskRequest_Dequeue_)(nil),
		(*DequeueTaskRequest_Succeed_)(nil),
		(*DequeueTaskRequest_Fail_)(nil),
	}
	file_interservice_cereal_cereal_proto_msgTypes[16].OneofWrappers = []any{
		(*DequeueTaskResponse_Dequeue_)(nil),
		(*DequeueTaskResponse_Cancel_)(nil),
		(*DequeueTaskResponse_Committed_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_interservice_cereal_cereal_proto_rawDesc), len(file_interservice_cereal_cereal_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   47,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_interservice_cereal_cereal_proto_goTypes,
		DependencyIndexes: file_interservice_cereal_cereal_proto_depIdxs,
		MessageInfos:      file_interservice_cereal_cereal_proto_msgTypes,
	}.Build()
	File_interservice_cereal_cereal_proto = out.File
	file_interservice_cereal_cereal_proto_goTypes = nil
	file_interservice_cereal_cereal_proto_depIdxs = nil
}

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

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

// CerealServiceClient is the client API for CerealService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CerealServiceClient interface {
	EnqueueWorkflow(ctx context.Context, in *EnqueueWorkflowRequest, opts ...grpc.CallOption) (*EnqueueWorkflowResponse, error)
	DequeueWorkflow(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueWorkflowClient, error)
	DequeueWorkflowChunk(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueWorkflowChunkClient, error)
	CancelWorkflow(ctx context.Context, in *CancelWorkflowRequest, opts ...grpc.CallOption) (*CancelWorkflowResponse, error)
	KillWorkflow(ctx context.Context, in *KillWorkflowRequest, opts ...grpc.CallOption) (*KillWorkflowResponse, error)
	DequeueTask(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueTaskClient, error)
	CreateWorkflowSchedule(ctx context.Context, in *CreateWorkflowScheduleRequest, opts ...grpc.CallOption) (*CreateWorkflowScheduleResponse, error)
	ListWorkflowSchedules(ctx context.Context, in *ListWorkflowSchedulesRequest, opts ...grpc.CallOption) (CerealService_ListWorkflowSchedulesClient, error)
	GetWorkflowScheduleByName(ctx context.Context, in *GetWorkflowScheduleByNameRequest, opts ...grpc.CallOption) (*GetWorkflowScheduleByNameResponse, error)
	UpdateWorkflowScheduleByName(ctx context.Context, in *UpdateWorkflowScheduleByNameRequest, opts ...grpc.CallOption) (*UpdateWorkflowScheduleByNameResponse, error)
	GetWorkflowInstanceByName(ctx context.Context, in *GetWorkflowInstanceByNameRequest, opts ...grpc.CallOption) (*GetWorkflowInstanceByNameResponse, error)
	ListWorkflowInstances(ctx context.Context, in *ListWorkflowInstancesRequest, opts ...grpc.CallOption) (CerealService_ListWorkflowInstancesClient, error)
}

type cerealServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCerealServiceClient(cc grpc.ClientConnInterface) CerealServiceClient {
	return &cerealServiceClient{cc}
}

func (c *cerealServiceClient) EnqueueWorkflow(ctx context.Context, in *EnqueueWorkflowRequest, opts ...grpc.CallOption) (*EnqueueWorkflowResponse, error) {
	out := new(EnqueueWorkflowResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/EnqueueWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) DequeueWorkflow(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueWorkflowClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CerealService_serviceDesc.Streams[0], "/chef.automate.infra.cereal.CerealService/DequeueWorkflow", opts...)
	if err != nil {
		return nil, err
	}
	x := &cerealServiceDequeueWorkflowClient{stream}
	return x, nil
}

type CerealService_DequeueWorkflowClient interface {
	Send(*DequeueWorkflowRequest) error
	Recv() (*DequeueWorkflowResponse, error)
	grpc.ClientStream
}

type cerealServiceDequeueWorkflowClient struct {
	grpc.ClientStream
}

func (x *cerealServiceDequeueWorkflowClient) Send(m *DequeueWorkflowRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *cerealServiceClient) DequeueWorkflowChunk(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueWorkflowChunkClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CerealService_serviceDesc.Streams[1], "/chef.automate.infra.cereal.CerealService/DequeueWorkflowChunk", opts...)
	if err != nil {
		return nil, err
	}
	x := &cerealServiceDequeueWorkflowChunkClient{stream}
	return x, nil
}

type CerealService_DequeueWorkflowChunkClient interface {
	Send(*DequeueWorkflowChunkRequest) error
	Recv() (*DequeueWorkflowChunkResponse, error)
	grpc.ClientStream
}

type cerealServiceDequeueWorkflowChunkClient struct {
	grpc.ClientStream
}

func (x *cerealServiceDequeueWorkflowChunkClient) Send(m *DequeueWorkflowChunkRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *cerealServiceClient) CancelWorkflow(ctx context.Context, in *CancelWorkflowRequest, opts ...grpc.CallOption) (*CancelWorkflowResponse, error) {
	out := new(CancelWorkflowResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/CancelWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) KillWorkflow(ctx context.Context, in *KillWorkflowRequest, opts ...grpc.CallOption) (*KillWorkflowResponse, error) {
	out := new(KillWorkflowResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/KillWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) DequeueTask(ctx context.Context, opts ...grpc.CallOption) (CerealService_DequeueTaskClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CerealService_serviceDesc.Streams[2], "/chef.automate.infra.cereal.CerealService/DequeueTask", opts...)
	if err != nil {
		return nil, err
	}
	x := &cerealServiceDequeueTaskClient{stream}
	return x, nil
}

type CerealService_DequeueTaskClient interface {
	Send(*DequeueTaskRequest) error
	Recv() (*DequeueTaskResponse, error)
	grpc.ClientStream
}

type cerealServiceDequeueTaskClient struct {
	grpc.ClientStream
}

func (x *cerealServiceDequeueTaskClient) Send(m *DequeueTaskRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *cerealServiceClient) CreateWorkflowSchedule(ctx context.Context, in *CreateWorkflowScheduleRequest, opts ...grpc.CallOption) (*CreateWorkflowScheduleResponse, error) {
	out := new(CreateWorkflowScheduleResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/CreateWorkflowSchedule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) ListWorkflowSchedules(ctx context.Context, in *ListWorkflowSchedulesRequest, opts ...grpc.CallOption) (CerealService_ListWorkflowSchedulesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CerealService_serviceDesc.Streams[3], "/chef.automate.infra.cereal.CerealService/ListWorkflowSchedules", opts...)
	if err != nil {
		return nil, err
	}
	x := &cerealServiceListWorkflowSchedulesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CerealService_ListWorkflowSchedulesClient interface {
	Recv() (*ListWorkflowSchedulesResponse, error)
	grpc.ClientStream
}

type cerealServiceListWorkflowSchedulesClient struct {
	grpc.ClientStream
}

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

func (c *cerealServiceClient) GetWorkflowScheduleByName(ctx context.Context, in *GetWorkflowScheduleByNameRequest, opts ...grpc.CallOption) (*GetWorkflowScheduleByNameResponse, error) {
	out := new(GetWorkflowScheduleByNameResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/GetWorkflowScheduleByName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) UpdateWorkflowScheduleByName(ctx context.Context, in *UpdateWorkflowScheduleByNameRequest, opts ...grpc.CallOption) (*UpdateWorkflowScheduleByNameResponse, error) {
	out := new(UpdateWorkflowScheduleByNameResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/UpdateWorkflowScheduleByName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) GetWorkflowInstanceByName(ctx context.Context, in *GetWorkflowInstanceByNameRequest, opts ...grpc.CallOption) (*GetWorkflowInstanceByNameResponse, error) {
	out := new(GetWorkflowInstanceByNameResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.infra.cereal.CerealService/GetWorkflowInstanceByName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerealServiceClient) ListWorkflowInstances(ctx context.Context, in *ListWorkflowInstancesRequest, opts ...grpc.CallOption) (CerealService_ListWorkflowInstancesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CerealService_serviceDesc.Streams[4], "/chef.automate.infra.cereal.CerealService/ListWorkflowInstances", opts...)
	if err != nil {
		return nil, err
	}
	x := &cerealServiceListWorkflowInstancesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CerealService_ListWorkflowInstancesClient interface {
	Recv() (*ListWorkflowInstancesResponse, error)
	grpc.ClientStream
}

type cerealServiceListWorkflowInstancesClient struct {
	grpc.ClientStream
}

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

// CerealServiceServer is the server API for CerealService service.
type CerealServiceServer interface {
	EnqueueWorkflow(context.Context, *EnqueueWorkflowRequest) (*EnqueueWorkflowResponse, error)
	DequeueWorkflow(CerealService_DequeueWorkflowServer) error
	DequeueWorkflowChunk(CerealService_DequeueWorkflowChunkServer) error
	CancelWorkflow(context.Context, *CancelWorkflowRequest) (*CancelWorkflowResponse, error)
	KillWorkflow(context.Context, *KillWorkflowRequest) (*KillWorkflowResponse, error)
	DequeueTask(CerealService_DequeueTaskServer) error
	CreateWorkflowSchedule(context.Context, *CreateWorkflowScheduleRequest) (*CreateWorkflowScheduleResponse, error)
	ListWorkflowSchedules(*ListWorkflowSchedulesRequest, CerealService_ListWorkflowSchedulesServer) error
	GetWorkflowScheduleByName(context.Context, *GetWorkflowScheduleByNameRequest) (*GetWorkflowScheduleByNameResponse, error)
	UpdateWorkflowScheduleByName(context.Context, *UpdateWorkflowScheduleByNameRequest) (*UpdateWorkflowScheduleByNameResponse, error)
	GetWorkflowInstanceByName(context.Context, *GetWorkflowInstanceByNameRequest) (*GetWorkflowInstanceByNameResponse, error)
	ListWorkflowInstances(*ListWorkflowInstancesRequest, CerealService_ListWorkflowInstancesServer) error
}

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

func (*UnimplementedCerealServiceServer) EnqueueWorkflow(context.Context, *EnqueueWorkflowRequest) (*EnqueueWorkflowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnqueueWorkflow not implemented")
}
func (*UnimplementedCerealServiceServer) DequeueWorkflow(CerealService_DequeueWorkflowServer) error {
	return status.Errorf(codes.Unimplemented, "method DequeueWorkflow not implemented")
}
func (*UnimplementedCerealServiceServer) DequeueWorkflowChunk(CerealService_DequeueWorkflowChunkServer) error {
	return status.Errorf(codes.Unimplemented, "method DequeueWorkflowChunk not implemented")
}
func (*UnimplementedCerealServiceServer) CancelWorkflow(context.Context, *CancelWorkflowRequest) (*CancelWorkflowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelWorkflow not implemented")
}
func (*UnimplementedCerealServiceServer) KillWorkflow(context.Context, *KillWorkflowRequest) (*KillWorkflowResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method KillWorkflow not implemented")
}
func (*UnimplementedCerealServiceServer) DequeueTask(CerealService_DequeueTaskServer) error {
	return status.Errorf(codes.Unimplemented, "method DequeueTask not implemented")
}
func (*UnimplementedCerealServiceServer) CreateWorkflowSchedule(context.Context, *CreateWorkflowScheduleRequest) (*CreateWorkflowScheduleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateWorkflowSchedule not implemented")
}
func (*UnimplementedCerealServiceServer) ListWorkflowSchedules(*ListWorkflowSchedulesRequest, CerealService_ListWorkflowSchedulesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListWorkflowSchedules not implemented")
}
func (*UnimplementedCerealServiceServer) GetWorkflowScheduleByName(context.Context, *GetWorkflowScheduleByNameRequest) (*GetWorkflowScheduleByNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowScheduleByName not implemented")
}
func (*UnimplementedCerealServiceServer) UpdateWorkflowScheduleByName(context.Context, *UpdateWorkflowScheduleByNameRequest) (*UpdateWorkflowScheduleByNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateWorkflowScheduleByName not implemented")
}
func (*UnimplementedCerealServiceServer) GetWorkflowInstanceByName(context.Context, *GetWorkflowInstanceByNameRequest) (*GetWorkflowInstanceByNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowInstanceByName not implemented")
}
func (*UnimplementedCerealServiceServer) ListWorkflowInstances(*ListWorkflowInstancesRequest, CerealService_ListWorkflowInstancesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListWorkflowInstances not implemented")
}

func RegisterCerealServiceServer(s *grpc.Server, srv CerealServiceServer) {
	s.RegisterService(&_CerealService_serviceDesc, srv)
}

func _CerealService_EnqueueWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnqueueWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).EnqueueWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/EnqueueWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).EnqueueWorkflow(ctx, req.(*EnqueueWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_DequeueWorkflow_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CerealServiceServer).DequeueWorkflow(&cerealServiceDequeueWorkflowServer{stream})
}

type CerealService_DequeueWorkflowServer interface {
	Send(*DequeueWorkflowResponse) error
	Recv() (*DequeueWorkflowRequest, error)
	grpc.ServerStream
}

type cerealServiceDequeueWorkflowServer struct {
	grpc.ServerStream
}

func (x *cerealServiceDequeueWorkflowServer) Send(m *DequeueWorkflowResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _CerealService_DequeueWorkflowChunk_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CerealServiceServer).DequeueWorkflowChunk(&cerealServiceDequeueWorkflowChunkServer{stream})
}

type CerealService_DequeueWorkflowChunkServer interface {
	Send(*DequeueWorkflowChunkResponse) error
	Recv() (*DequeueWorkflowChunkRequest, error)
	grpc.ServerStream
}

type cerealServiceDequeueWorkflowChunkServer struct {
	grpc.ServerStream
}

func (x *cerealServiceDequeueWorkflowChunkServer) Send(m *DequeueWorkflowChunkResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _CerealService_CancelWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).CancelWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/CancelWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).CancelWorkflow(ctx, req.(*CancelWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_KillWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KillWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).KillWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/KillWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).KillWorkflow(ctx, req.(*KillWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_DequeueTask_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CerealServiceServer).DequeueTask(&cerealServiceDequeueTaskServer{stream})
}

type CerealService_DequeueTaskServer interface {
	Send(*DequeueTaskResponse) error
	Recv() (*DequeueTaskRequest, error)
	grpc.ServerStream
}

type cerealServiceDequeueTaskServer struct {
	grpc.ServerStream
}

func (x *cerealServiceDequeueTaskServer) Send(m *DequeueTaskResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _CerealService_CreateWorkflowSchedule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateWorkflowScheduleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).CreateWorkflowSchedule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/CreateWorkflowSchedule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).CreateWorkflowSchedule(ctx, req.(*CreateWorkflowScheduleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_ListWorkflowSchedules_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListWorkflowSchedulesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CerealServiceServer).ListWorkflowSchedules(m, &cerealServiceListWorkflowSchedulesServer{stream})
}

type CerealService_ListWorkflowSchedulesServer interface {
	Send(*ListWorkflowSchedulesResponse) error
	grpc.ServerStream
}

type cerealServiceListWorkflowSchedulesServer struct {
	grpc.ServerStream
}

func (x *cerealServiceListWorkflowSchedulesServer) Send(m *ListWorkflowSchedulesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CerealService_GetWorkflowScheduleByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWorkflowScheduleByNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).GetWorkflowScheduleByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/GetWorkflowScheduleByName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).GetWorkflowScheduleByName(ctx, req.(*GetWorkflowScheduleByNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_UpdateWorkflowScheduleByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateWorkflowScheduleByNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).UpdateWorkflowScheduleByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/UpdateWorkflowScheduleByName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).UpdateWorkflowScheduleByName(ctx, req.(*UpdateWorkflowScheduleByNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_GetWorkflowInstanceByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWorkflowInstanceByNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerealServiceServer).GetWorkflowInstanceByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.infra.cereal.CerealService/GetWorkflowInstanceByName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerealServiceServer).GetWorkflowInstanceByName(ctx, req.(*GetWorkflowInstanceByNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerealService_ListWorkflowInstances_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListWorkflowInstancesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CerealServiceServer).ListWorkflowInstances(m, &cerealServiceListWorkflowInstancesServer{stream})
}

type CerealService_ListWorkflowInstancesServer interface {
	Send(*ListWorkflowInstancesResponse) error
	grpc.ServerStream
}

type cerealServiceListWorkflowInstancesServer struct {
	grpc.ServerStream
}

func (x *cerealServiceListWorkflowInstancesServer) Send(m *ListWorkflowInstancesResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _CerealService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chef.automate.infra.cereal.CerealService",
	HandlerType: (*CerealServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "EnqueueWorkflow",
			Handler:    _CerealService_EnqueueWorkflow_Handler,
		},
		{
			MethodName: "CancelWorkflow",
			Handler:    _CerealService_CancelWorkflow_Handler,
		},
		{
			MethodName: "KillWorkflow",
			Handler:    _CerealService_KillWorkflow_Handler,
		},
		{
			MethodName: "CreateWorkflowSchedule",
			Handler:    _CerealService_CreateWorkflowSchedule_Handler,
		},
		{
			MethodName: "GetWorkflowScheduleByName",
			Handler:    _CerealService_GetWorkflowScheduleByName_Handler,
		},
		{
			MethodName: "UpdateWorkflowScheduleByName",
			Handler:    _CerealService_UpdateWorkflowScheduleByName_Handler,
		},
		{
			MethodName: "GetWorkflowInstanceByName",
			Handler:    _CerealService_GetWorkflowInstanceByName_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "DequeueWorkflow",
			Handler:       _CerealService_DequeueWorkflow_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "DequeueWorkflowChunk",
			Handler:       _CerealService_DequeueWorkflowChunk_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "DequeueTask",
			Handler:       _CerealService_DequeueTask_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "ListWorkflowSchedules",
			Handler:       _CerealService_ListWorkflowSchedules_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListWorkflowInstances",
			Handler:       _CerealService_ListWorkflowInstances_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "interservice/cereal/cereal.proto",
}
