go/proto/admin/v1/queue.pb.go

// The MIT License (MIT)
// 
// Copyright (c) 2021 Uber Technologies, Inc.
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: uber/cadence/admin/v1/queue.proto

package adminv1

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	v1 "github.com/uber/cadence-idl/go/proto/api/v1"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type TaskType int32

const (
	TaskType_TASK_TYPE_INVALID       TaskType = 0
	TaskType_TASK_TYPE_TRANSFER      TaskType = 1
	TaskType_TASK_TYPE_TIMER         TaskType = 2
	TaskType_TASK_TYPE_REPLICATION   TaskType = 3
	TaskType_TASK_TYPE_CROSS_CLUSTER TaskType = 4
)

var TaskType_name = map[int32]string{
	0: "TASK_TYPE_INVALID",
	1: "TASK_TYPE_TRANSFER",
	2: "TASK_TYPE_TIMER",
	3: "TASK_TYPE_REPLICATION",
	4: "TASK_TYPE_CROSS_CLUSTER",
}

var TaskType_value = map[string]int32{
	"TASK_TYPE_INVALID":       0,
	"TASK_TYPE_TRANSFER":      1,
	"TASK_TYPE_TIMER":         2,
	"TASK_TYPE_REPLICATION":   3,
	"TASK_TYPE_CROSS_CLUSTER": 4,
}

func (x TaskType) String() string {
	return proto.EnumName(TaskType_name, int32(x))
}

func (TaskType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8d7963584a31be0a, []int{0}
}

type CrossClusterTaskType int32

const (
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_INVALID                                  CrossClusterTaskType = 0
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_START_CHILD_EXECUTION                    CrossClusterTaskType = 1
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_CANCEL_EXECUTION                         CrossClusterTaskType = 2
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_SIGNAL_EXECUTION                         CrossClusterTaskType = 3
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_RECORD_CHILD_WORKKLOW_EXECUTION_COMPLETE CrossClusterTaskType = 4
	CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_APPLY_PARENT_CLOSE_POLICY                CrossClusterTaskType = 5
)

var CrossClusterTaskType_name = map[int32]string{
	0: "CROSS_CLUSTER_TASK_TYPE_INVALID",
	1: "CROSS_CLUSTER_TASK_TYPE_START_CHILD_EXECUTION",
	2: "CROSS_CLUSTER_TASK_TYPE_CANCEL_EXECUTION",
	3: "CROSS_CLUSTER_TASK_TYPE_SIGNAL_EXECUTION",
	4: "CROSS_CLUSTER_TASK_TYPE_RECORD_CHILD_WORKKLOW_EXECUTION_COMPLETE",
	5: "CROSS_CLUSTER_TASK_TYPE_APPLY_PARENT_CLOSE_POLICY",
}

var CrossClusterTaskType_value = map[string]int32{
	"CROSS_CLUSTER_TASK_TYPE_INVALID":                                  0,
	"CROSS_CLUSTER_TASK_TYPE_START_CHILD_EXECUTION":                    1,
	"CROSS_CLUSTER_TASK_TYPE_CANCEL_EXECUTION":                         2,
	"CROSS_CLUSTER_TASK_TYPE_SIGNAL_EXECUTION":                         3,
	"CROSS_CLUSTER_TASK_TYPE_RECORD_CHILD_WORKKLOW_EXECUTION_COMPLETE": 4,
	"CROSS_CLUSTER_TASK_TYPE_APPLY_PARENT_CLOSE_POLICY":                5,
}

func (x CrossClusterTaskType) String() string {
	return proto.EnumName(CrossClusterTaskType_name, int32(x))
}

func (CrossClusterTaskType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8d7963584a31be0a, []int{1}
}

type CrossClusterTaskFailedCause int32

const (
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID                    CrossClusterTaskFailedCause = 0
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_ACTIVE          CrossClusterTaskFailedCause = 1
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_EXISTS          CrossClusterTaskFailedCause = 2
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING   CrossClusterTaskFailedCause = 3
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_NOT_EXISTS        CrossClusterTaskFailedCause = 4
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED CrossClusterTaskFailedCause = 5
	CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_UNCATEGORIZED              CrossClusterTaskFailedCause = 6
)

var CrossClusterTaskFailedCause_name = map[int32]string{
	0: "CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID",
	1: "CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_ACTIVE",
	2: "CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_EXISTS",
	3: "CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING",
	4: "CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_NOT_EXISTS",
	5: "CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED",
	6: "CROSS_CLUSTER_TASK_FAILED_CAUSE_UNCATEGORIZED",
}

var CrossClusterTaskFailedCause_value = map[string]int32{
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID":                    0,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_ACTIVE":          1,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_EXISTS":          2,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING":   3,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_NOT_EXISTS":        4,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED": 5,
	"CROSS_CLUSTER_TASK_FAILED_CAUSE_UNCATEGORIZED":              6,
}

func (x CrossClusterTaskFailedCause) String() string {
	return proto.EnumName(CrossClusterTaskFailedCause_name, int32(x))
}

func (CrossClusterTaskFailedCause) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8d7963584a31be0a, []int{2}
}

type GetTaskFailedCause int32

const (
	GetTaskFailedCause_GET_TASK_FAILED_CAUSE_INVALID              GetTaskFailedCause = 0
	GetTaskFailedCause_GET_TASK_FAILED_CAUSE_SERVICE_BUSY         GetTaskFailedCause = 1
	GetTaskFailedCause_GET_TASK_FAILED_CAUSE_TIMEOUT              GetTaskFailedCause = 2
	GetTaskFailedCause_GET_TASK_FAILED_CAUSE_SHARD_OWNERSHIP_LOST GetTaskFailedCause = 3
	GetTaskFailedCause_GET_TASK_FAILED_CAUSE_UNCATEGORIZED        GetTaskFailedCause = 4
)

var GetTaskFailedCause_name = map[int32]string{
	0: "GET_TASK_FAILED_CAUSE_INVALID",
	1: "GET_TASK_FAILED_CAUSE_SERVICE_BUSY",
	2: "GET_TASK_FAILED_CAUSE_TIMEOUT",
	3: "GET_TASK_FAILED_CAUSE_SHARD_OWNERSHIP_LOST",
	4: "GET_TASK_FAILED_CAUSE_UNCATEGORIZED",
}

var GetTaskFailedCause_value = map[string]int32{
	"GET_TASK_FAILED_CAUSE_INVALID":              0,
	"GET_TASK_FAILED_CAUSE_SERVICE_BUSY":         1,
	"GET_TASK_FAILED_CAUSE_TIMEOUT":              2,
	"GET_TASK_FAILED_CAUSE_SHARD_OWNERSHIP_LOST": 3,
	"GET_TASK_FAILED_CAUSE_UNCATEGORIZED":        4,
}

func (x GetTaskFailedCause) String() string {
	return proto.EnumName(GetTaskFailedCause_name, int32(x))
}

func (GetTaskFailedCause) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8d7963584a31be0a, []int{3}
}

type CrossClusterTaskInfo struct {
	DomainId             string                `protobuf:"bytes,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
	WorkflowExecution    *v1.WorkflowExecution `protobuf:"bytes,2,opt,name=workflow_execution,json=workflowExecution,proto3" json:"workflow_execution,omitempty"`
	TaskType             CrossClusterTaskType  `protobuf:"varint,3,opt,name=task_type,json=taskType,proto3,enum=uber.cadence.admin.v1.CrossClusterTaskType" json:"task_type,omitempty"`
	TaskState            int32                 `protobuf:"varint,4,opt,name=task_state,json=taskState,proto3" json:"task_state,omitempty"`
	TaskId               int64                 `protobuf:"varint,5,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	VisibilityTimestamp  *types.Timestamp      `protobuf:"bytes,6,opt,name=visibility_timestamp,json=visibilityTimestamp,proto3" json:"visibility_timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_CrossClusterTaskInfo proto.InternalMessageInfo

func (m *CrossClusterTaskInfo) GetDomainId() string {
	if m != nil {
		return m.DomainId
	}
	return ""
}

func (m *CrossClusterTaskInfo) GetWorkflowExecution() *v1.WorkflowExecution {
	if m != nil {
		return m.WorkflowExecution
	}
	return nil
}

func (m *CrossClusterTaskInfo) GetTaskType() CrossClusterTaskType {
	if m != nil {
		return m.TaskType
	}
	return CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_INVALID
}

func (m *CrossClusterTaskInfo) GetTaskState() int32 {
	if m != nil {
		return m.TaskState
	}
	return 0
}

func (m *CrossClusterTaskInfo) GetTaskId() int64 {
	if m != nil {
		return m.TaskId
	}
	return 0
}

func (m *CrossClusterTaskInfo) GetVisibilityTimestamp() *types.Timestamp {
	if m != nil {
		return m.VisibilityTimestamp
	}
	return nil
}

type CrossClusterStartChildExecutionRequestAttributes struct {
	TargetDomainId           string                                                  `protobuf:"bytes,1,opt,name=target_domain_id,json=targetDomainId,proto3" json:"target_domain_id,omitempty"`
	RequestId                string                                                  `protobuf:"bytes,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	InitiatedEventId         int64                                                   `protobuf:"varint,3,opt,name=initiated_event_id,json=initiatedEventId,proto3" json:"initiated_event_id,omitempty"`
	InitiatedEventAttributes *v1.StartChildWorkflowExecutionInitiatedEventAttributes `protobuf:"bytes,4,opt,name=initiated_event_attributes,json=initiatedEventAttributes,proto3" json:"initiated_event_attributes,omitempty"`
	// targetRunID is for scheduling first decision task
	// targetWorkflowID is available in initiatedEventAttributes
	TargetRunId          string            `protobuf:"bytes,5,opt,name=target_run_id,json=targetRunId,proto3" json:"target_run_id,omitempty"`
	PartitionConfig      map[string]string `protobuf:"bytes,6,rep,name=partition_config,json=partitionConfig,proto3" json:"partition_config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_CrossClusterStartChildExecutionRequestAttributes proto.InternalMessageInfo

func (m *CrossClusterStartChildExecutionRequestAttributes) GetTargetDomainId() string {
	if m != nil {
		return m.TargetDomainId
	}
	return ""
}

func (m *CrossClusterStartChildExecutionRequestAttributes) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *CrossClusterStartChildExecutionRequestAttributes) GetInitiatedEventId() int64 {
	if m != nil {
		return m.InitiatedEventId
	}
	return 0
}

func (m *CrossClusterStartChildExecutionRequestAttributes) GetInitiatedEventAttributes() *v1.StartChildWorkflowExecutionInitiatedEventAttributes {
	if m != nil {
		return m.InitiatedEventAttributes
	}
	return nil
}

func (m *CrossClusterStartChildExecutionRequestAttributes) GetTargetRunId() string {
	if m != nil {
		return m.TargetRunId
	}
	return ""
}

func (m *CrossClusterStartChildExecutionRequestAttributes) GetPartitionConfig() map[string]string {
	if m != nil {
		return m.PartitionConfig
	}
	return nil
}

type CrossClusterStartChildExecutionResponseAttributes struct {
	RunId                string   `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CrossClusterStartChildExecutionResponseAttributes proto.InternalMessageInfo

func (m *CrossClusterStartChildExecutionResponseAttributes) GetRunId() string {
	if m != nil {
		return m.RunId
	}
	return ""
}

type CrossClusterCancelExecutionRequestAttributes struct {
	TargetDomainId          string                `protobuf:"bytes,1,opt,name=target_domain_id,json=targetDomainId,proto3" json:"target_domain_id,omitempty"`
	TargetWorkflowExecution *v1.WorkflowExecution `protobuf:"bytes,2,opt,name=target_workflow_execution,json=targetWorkflowExecution,proto3" json:"target_workflow_execution,omitempty"`
	RequestId               string                `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	InitiatedEventId        int64                 `protobuf:"varint,4,opt,name=initiated_event_id,json=initiatedEventId,proto3" json:"initiated_event_id,omitempty"`
	ChildWorkflowOnly       bool                  `protobuf:"varint,5,opt,name=child_workflow_only,json=childWorkflowOnly,proto3" json:"child_workflow_only,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}              `json:"-"`
	XXX_unrecognized        []byte                `json:"-"`
	XXX_sizecache           int32                 `json:"-"`
}

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

var xxx_messageInfo_CrossClusterCancelExecutionRequestAttributes proto.InternalMessageInfo

func (m *CrossClusterCancelExecutionRequestAttributes) GetTargetDomainId() string {
	if m != nil {
		return m.TargetDomainId
	}
	return ""
}

func (m *CrossClusterCancelExecutionRequestAttributes) GetTargetWorkflowExecution() *v1.WorkflowExecution {
	if m != nil {
		return m.TargetWorkflowExecution
	}
	return nil
}

func (m *CrossClusterCancelExecutionRequestAttributes) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *CrossClusterCancelExecutionRequestAttributes) GetInitiatedEventId() int64 {
	if m != nil {
		return m.InitiatedEventId
	}
	return 0
}

func (m *CrossClusterCancelExecutionRequestAttributes) GetChildWorkflowOnly() bool {
	if m != nil {
		return m.ChildWorkflowOnly
	}
	return false
}

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

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

var xxx_messageInfo_CrossClusterCancelExecutionResponseAttributes proto.InternalMessageInfo

type CrossClusterSignalExecutionRequestAttributes struct {
	TargetDomainId          string                `protobuf:"bytes,1,opt,name=target_domain_id,json=targetDomainId,proto3" json:"target_domain_id,omitempty"`
	TargetWorkflowExecution *v1.WorkflowExecution `protobuf:"bytes,2,opt,name=target_workflow_execution,json=targetWorkflowExecution,proto3" json:"target_workflow_execution,omitempty"`
	RequestId               string                `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	InitiatedEventId        int64                 `protobuf:"varint,4,opt,name=initiated_event_id,json=initiatedEventId,proto3" json:"initiated_event_id,omitempty"`
	ChildWorkflowOnly       bool                  `protobuf:"varint,5,opt,name=child_workflow_only,json=childWorkflowOnly,proto3" json:"child_workflow_only,omitempty"`
	SignalName              string                `protobuf:"bytes,6,opt,name=signal_name,json=signalName,proto3" json:"signal_name,omitempty"`
	SignalInput             *v1.Payload           `protobuf:"bytes,7,opt,name=signal_input,json=signalInput,proto3" json:"signal_input,omitempty"`
	Control                 []byte                `protobuf:"bytes,8,opt,name=control,proto3" json:"control,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}              `json:"-"`
	XXX_unrecognized        []byte                `json:"-"`
	XXX_sizecache           int32                 `json:"-"`
}

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

var xxx_messageInfo_CrossClusterSignalExecutionRequestAttributes proto.InternalMessageInfo

func (m *CrossClusterSignalExecutionRequestAttributes) GetTargetDomainId() string {
	if m != nil {
		return m.TargetDomainId
	}
	return ""
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetTargetWorkflowExecution() *v1.WorkflowExecution {
	if m != nil {
		return m.TargetWorkflowExecution
	}
	return nil
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetInitiatedEventId() int64 {
	if m != nil {
		return m.InitiatedEventId
	}
	return 0
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetChildWorkflowOnly() bool {
	if m != nil {
		return m.ChildWorkflowOnly
	}
	return false
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetSignalName() string {
	if m != nil {
		return m.SignalName
	}
	return ""
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetSignalInput() *v1.Payload {
	if m != nil {
		return m.SignalInput
	}
	return nil
}

func (m *CrossClusterSignalExecutionRequestAttributes) GetControl() []byte {
	if m != nil {
		return m.Control
	}
	return nil
}

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

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

var xxx_messageInfo_CrossClusterSignalExecutionResponseAttributes proto.InternalMessageInfo

type CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes struct {
	TargetDomainId          string                `protobuf:"bytes,1,opt,name=target_domain_id,json=targetDomainId,proto3" json:"target_domain_id,omitempty"`
	TargetWorkflowExecution *v1.WorkflowExecution `protobuf:"bytes,2,opt,name=target_workflow_execution,json=targetWorkflowExecution,proto3" json:"target_workflow_execution,omitempty"`
	InitiatedEventId        int64                 `protobuf:"varint,3,opt,name=initiated_event_id,json=initiatedEventId,proto3" json:"initiated_event_id,omitempty"`
	CompletionEvent         *v1.HistoryEvent      `protobuf:"bytes,4,opt,name=completion_event,json=completionEvent,proto3" json:"completion_event,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}              `json:"-"`
	XXX_unrecognized        []byte                `json:"-"`
	XXX_sizecache           int32                 `json:"-"`
}

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

var xxx_messageInfo_CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes proto.InternalMessageInfo

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) GetTargetDomainId() string {
	if m != nil {
		return m.TargetDomainId
	}
	return ""
}

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) GetTargetWorkflowExecution() *v1.WorkflowExecution {
	if m != nil {
		return m.TargetWorkflowExecution
	}
	return nil
}

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) GetInitiatedEventId() int64 {
	if m != nil {
		return m.InitiatedEventId
	}
	return 0
}

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) GetCompletionEvent() *v1.HistoryEvent {
	if m != nil {
		return m.CompletionEvent
	}
	return nil
}

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

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

var xxx_messageInfo_CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes proto.InternalMessageInfo

type ApplyParentClosePolicyAttributes struct {
	ChildDomainId        string               `protobuf:"bytes,1,opt,name=child_domain_id,json=childDomainId,proto3" json:"child_domain_id,omitempty"`
	ChildWorkflowId      string               `protobuf:"bytes,2,opt,name=child_workflow_id,json=childWorkflowId,proto3" json:"child_workflow_id,omitempty"`
	ChildRunId           string               `protobuf:"bytes,3,opt,name=child_run_id,json=childRunId,proto3" json:"child_run_id,omitempty"`
	ParentClosePolicy    v1.ParentClosePolicy `protobuf:"varint,4,opt,name=parent_close_policy,json=parentClosePolicy,proto3,enum=uber.cadence.api.v1.ParentClosePolicy" json:"parent_close_policy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_ApplyParentClosePolicyAttributes proto.InternalMessageInfo

func (m *ApplyParentClosePolicyAttributes) GetChildDomainId() string {
	if m != nil {
		return m.ChildDomainId
	}
	return ""
}

func (m *ApplyParentClosePolicyAttributes) GetChildWorkflowId() string {
	if m != nil {
		return m.ChildWorkflowId
	}
	return ""
}

func (m *ApplyParentClosePolicyAttributes) GetChildRunId() string {
	if m != nil {
		return m.ChildRunId
	}
	return ""
}

func (m *ApplyParentClosePolicyAttributes) GetParentClosePolicy() v1.ParentClosePolicy {
	if m != nil {
		return m.ParentClosePolicy
	}
	return v1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID
}

type ApplyParentClosePolicyStatus struct {
	Completed            bool                        `protobuf:"varint,1,opt,name=completed,proto3" json:"completed,omitempty"`
	FailedCause          CrossClusterTaskFailedCause `protobuf:"varint,2,opt,name=failed_cause,json=failedCause,proto3,enum=uber.cadence.admin.v1.CrossClusterTaskFailedCause" json:"failed_cause,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_ApplyParentClosePolicyStatus proto.InternalMessageInfo

func (m *ApplyParentClosePolicyStatus) GetCompleted() bool {
	if m != nil {
		return m.Completed
	}
	return false
}

func (m *ApplyParentClosePolicyStatus) GetFailedCause() CrossClusterTaskFailedCause {
	if m != nil {
		return m.FailedCause
	}
	return CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID
}

type ApplyParentClosePolicyRequest struct {
	Child                *ApplyParentClosePolicyAttributes `protobuf:"bytes,1,opt,name=child,proto3" json:"child,omitempty"`
	Status               *ApplyParentClosePolicyStatus     `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

var xxx_messageInfo_ApplyParentClosePolicyRequest proto.InternalMessageInfo

func (m *ApplyParentClosePolicyRequest) GetChild() *ApplyParentClosePolicyAttributes {
	if m != nil {
		return m.Child
	}
	return nil
}

func (m *ApplyParentClosePolicyRequest) GetStatus() *ApplyParentClosePolicyStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type CrossClusterApplyParentClosePolicyRequestAttributes struct {
	Children             []*ApplyParentClosePolicyRequest `protobuf:"bytes,1,rep,name=children,proto3" json:"children,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

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

var xxx_messageInfo_CrossClusterApplyParentClosePolicyRequestAttributes proto.InternalMessageInfo

func (m *CrossClusterApplyParentClosePolicyRequestAttributes) GetChildren() []*ApplyParentClosePolicyRequest {
	if m != nil {
		return m.Children
	}
	return nil
}

type ApplyParentClosePolicyResult struct {
	Child                *ApplyParentClosePolicyAttributes `protobuf:"bytes,1,opt,name=child,proto3" json:"child,omitempty"`
	FailedCause          CrossClusterTaskFailedCause       `protobuf:"varint,2,opt,name=failed_cause,json=failedCause,proto3,enum=uber.cadence.admin.v1.CrossClusterTaskFailedCause" json:"failed_cause,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

var xxx_messageInfo_ApplyParentClosePolicyResult proto.InternalMessageInfo

func (m *ApplyParentClosePolicyResult) GetChild() *ApplyParentClosePolicyAttributes {
	if m != nil {
		return m.Child
	}
	return nil
}

func (m *ApplyParentClosePolicyResult) GetFailedCause() CrossClusterTaskFailedCause {
	if m != nil {
		return m.FailedCause
	}
	return CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID
}

type CrossClusterApplyParentClosePolicyResponseAttributes struct {
	ChildrenStatus       []*ApplyParentClosePolicyResult `protobuf:"bytes,1,rep,name=children_status,json=childrenStatus,proto3" json:"children_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_CrossClusterApplyParentClosePolicyResponseAttributes proto.InternalMessageInfo

func (m *CrossClusterApplyParentClosePolicyResponseAttributes) GetChildrenStatus() []*ApplyParentClosePolicyResult {
	if m != nil {
		return m.ChildrenStatus
	}
	return nil
}

type CrossClusterTaskRequest struct {
	TaskInfo *CrossClusterTaskInfo `protobuf:"bytes,1,opt,name=task_info,json=taskInfo,proto3" json:"task_info,omitempty"`
	// Types that are valid to be assigned to Attributes:
	//	*CrossClusterTaskRequest_StartChildExecutionAttributes
	//	*CrossClusterTaskRequest_CancelExecutionAttributes
	//	*CrossClusterTaskRequest_SignalExecutionAttributes
	//	*CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes
	//	*CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes
	Attributes           isCrossClusterTaskRequest_Attributes `protobuf_oneof:"attributes"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

var xxx_messageInfo_CrossClusterTaskRequest proto.InternalMessageInfo

type isCrossClusterTaskRequest_Attributes interface {
	isCrossClusterTaskRequest_Attributes()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CrossClusterTaskRequest_StartChildExecutionAttributes struct {
	StartChildExecutionAttributes *CrossClusterStartChildExecutionRequestAttributes `protobuf:"bytes,2,opt,name=start_child_execution_attributes,json=startChildExecutionAttributes,proto3,oneof" json:"start_child_execution_attributes,omitempty"`
}
type CrossClusterTaskRequest_CancelExecutionAttributes struct {
	CancelExecutionAttributes *CrossClusterCancelExecutionRequestAttributes `protobuf:"bytes,3,opt,name=cancel_execution_attributes,json=cancelExecutionAttributes,proto3,oneof" json:"cancel_execution_attributes,omitempty"`
}
type CrossClusterTaskRequest_SignalExecutionAttributes struct {
	SignalExecutionAttributes *CrossClusterSignalExecutionRequestAttributes `protobuf:"bytes,4,opt,name=signal_execution_attributes,json=signalExecutionAttributes,proto3,oneof" json:"signal_execution_attributes,omitempty"`
}
type CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes struct {
	RecordChildWorkflowExecutionCompleteRequestAttributes *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes `protobuf:"bytes,5,opt,name=record_child_workflow_execution_complete_request_attributes,json=recordChildWorkflowExecutionCompleteRequestAttributes,proto3,oneof" json:"record_child_workflow_execution_complete_request_attributes,omitempty"`
}
type CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes struct {
	ApplyParentClosePolicyRequestAttributes *CrossClusterApplyParentClosePolicyRequestAttributes `protobuf:"bytes,6,opt,name=apply_parent_close_policy_request_attributes,json=applyParentClosePolicyRequestAttributes,proto3,oneof" json:"apply_parent_close_policy_request_attributes,omitempty"`
}

func (*CrossClusterTaskRequest_StartChildExecutionAttributes) isCrossClusterTaskRequest_Attributes() {
}
func (*CrossClusterTaskRequest_CancelExecutionAttributes) isCrossClusterTaskRequest_Attributes() {}
func (*CrossClusterTaskRequest_SignalExecutionAttributes) isCrossClusterTaskRequest_Attributes() {}
func (*CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes) isCrossClusterTaskRequest_Attributes() {
}
func (*CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes) isCrossClusterTaskRequest_Attributes() {
}

func (m *CrossClusterTaskRequest) GetAttributes() isCrossClusterTaskRequest_Attributes {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetTaskInfo() *CrossClusterTaskInfo {
	if m != nil {
		return m.TaskInfo
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetStartChildExecutionAttributes() *CrossClusterStartChildExecutionRequestAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskRequest_StartChildExecutionAttributes); ok {
		return x.StartChildExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetCancelExecutionAttributes() *CrossClusterCancelExecutionRequestAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskRequest_CancelExecutionAttributes); ok {
		return x.CancelExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetSignalExecutionAttributes() *CrossClusterSignalExecutionRequestAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskRequest_SignalExecutionAttributes); ok {
		return x.SignalExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetRecordChildWorkflowExecutionCompleteRequestAttributes() *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes); ok {
		return x.RecordChildWorkflowExecutionCompleteRequestAttributes
	}
	return nil
}

func (m *CrossClusterTaskRequest) GetApplyParentClosePolicyRequestAttributes() *CrossClusterApplyParentClosePolicyRequestAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes); ok {
		return x.ApplyParentClosePolicyRequestAttributes
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrossClusterTaskRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrossClusterTaskRequest_StartChildExecutionAttributes)(nil),
		(*CrossClusterTaskRequest_CancelExecutionAttributes)(nil),
		(*CrossClusterTaskRequest_SignalExecutionAttributes)(nil),
		(*CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes)(nil),
		(*CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes)(nil),
	}
}

type CrossClusterTaskResponse struct {
	TaskId      int64                       `protobuf:"varint,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	TaskType    CrossClusterTaskType        `protobuf:"varint,2,opt,name=task_type,json=taskType,proto3,enum=uber.cadence.admin.v1.CrossClusterTaskType" json:"task_type,omitempty"`
	TaskState   int32                       `protobuf:"varint,3,opt,name=task_state,json=taskState,proto3" json:"task_state,omitempty"`
	FailedCause CrossClusterTaskFailedCause `protobuf:"varint,4,opt,name=failed_cause,json=failedCause,proto3,enum=uber.cadence.admin.v1.CrossClusterTaskFailedCause" json:"failed_cause,omitempty"`
	// Types that are valid to be assigned to Attributes:
	//	*CrossClusterTaskResponse_StartChildExecutionAttributes
	//	*CrossClusterTaskResponse_CancelExecutionAttributes
	//	*CrossClusterTaskResponse_SignalExecutionAttributes
	//	*CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes
	//	*CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes
	Attributes           isCrossClusterTaskResponse_Attributes `protobuf_oneof:"attributes"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

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

var xxx_messageInfo_CrossClusterTaskResponse proto.InternalMessageInfo

type isCrossClusterTaskResponse_Attributes interface {
	isCrossClusterTaskResponse_Attributes()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CrossClusterTaskResponse_StartChildExecutionAttributes struct {
	StartChildExecutionAttributes *CrossClusterStartChildExecutionResponseAttributes `protobuf:"bytes,5,opt,name=start_child_execution_attributes,json=startChildExecutionAttributes,proto3,oneof" json:"start_child_execution_attributes,omitempty"`
}
type CrossClusterTaskResponse_CancelExecutionAttributes struct {
	CancelExecutionAttributes *CrossClusterCancelExecutionResponseAttributes `protobuf:"bytes,6,opt,name=cancel_execution_attributes,json=cancelExecutionAttributes,proto3,oneof" json:"cancel_execution_attributes,omitempty"`
}
type CrossClusterTaskResponse_SignalExecutionAttributes struct {
	SignalExecutionAttributes *CrossClusterSignalExecutionResponseAttributes `protobuf:"bytes,7,opt,name=signal_execution_attributes,json=signalExecutionAttributes,proto3,oneof" json:"signal_execution_attributes,omitempty"`
}
type CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes struct {
	RecordChildWorkflowExecutionCompleteRequestAttributes *CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes `protobuf:"bytes,8,opt,name=record_child_workflow_execution_complete_request_attributes,json=recordChildWorkflowExecutionCompleteRequestAttributes,proto3,oneof" json:"record_child_workflow_execution_complete_request_attributes,omitempty"`
}
type CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes struct {
	ApplyParentClosePolicyResponseAttributes *CrossClusterApplyParentClosePolicyResponseAttributes `protobuf:"bytes,9,opt,name=apply_parent_close_policy_response_attributes,json=applyParentClosePolicyResponseAttributes,proto3,oneof" json:"apply_parent_close_policy_response_attributes,omitempty"`
}

func (*CrossClusterTaskResponse_StartChildExecutionAttributes) isCrossClusterTaskResponse_Attributes() {
}
func (*CrossClusterTaskResponse_CancelExecutionAttributes) isCrossClusterTaskResponse_Attributes() {}
func (*CrossClusterTaskResponse_SignalExecutionAttributes) isCrossClusterTaskResponse_Attributes() {}
func (*CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes) isCrossClusterTaskResponse_Attributes() {
}
func (*CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes) isCrossClusterTaskResponse_Attributes() {
}

func (m *CrossClusterTaskResponse) GetAttributes() isCrossClusterTaskResponse_Attributes {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *CrossClusterTaskResponse) GetTaskId() int64 {
	if m != nil {
		return m.TaskId
	}
	return 0
}

func (m *CrossClusterTaskResponse) GetTaskType() CrossClusterTaskType {
	if m != nil {
		return m.TaskType
	}
	return CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_INVALID
}

func (m *CrossClusterTaskResponse) GetTaskState() int32 {
	if m != nil {
		return m.TaskState
	}
	return 0
}

func (m *CrossClusterTaskResponse) GetFailedCause() CrossClusterTaskFailedCause {
	if m != nil {
		return m.FailedCause
	}
	return CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID
}

func (m *CrossClusterTaskResponse) GetStartChildExecutionAttributes() *CrossClusterStartChildExecutionResponseAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskResponse_StartChildExecutionAttributes); ok {
		return x.StartChildExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskResponse) GetCancelExecutionAttributes() *CrossClusterCancelExecutionResponseAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskResponse_CancelExecutionAttributes); ok {
		return x.CancelExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskResponse) GetSignalExecutionAttributes() *CrossClusterSignalExecutionResponseAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskResponse_SignalExecutionAttributes); ok {
		return x.SignalExecutionAttributes
	}
	return nil
}

func (m *CrossClusterTaskResponse) GetRecordChildWorkflowExecutionCompleteRequestAttributes() *CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes); ok {
		return x.RecordChildWorkflowExecutionCompleteRequestAttributes
	}
	return nil
}

func (m *CrossClusterTaskResponse) GetApplyParentClosePolicyResponseAttributes() *CrossClusterApplyParentClosePolicyResponseAttributes {
	if x, ok := m.GetAttributes().(*CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes); ok {
		return x.ApplyParentClosePolicyResponseAttributes
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CrossClusterTaskResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CrossClusterTaskResponse_StartChildExecutionAttributes)(nil),
		(*CrossClusterTaskResponse_CancelExecutionAttributes)(nil),
		(*CrossClusterTaskResponse_SignalExecutionAttributes)(nil),
		(*CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes)(nil),
		(*CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes)(nil),
	}
}

type CrossClusterTaskRequests struct {
	TaskRequests         []*CrossClusterTaskRequest `protobuf:"bytes,1,rep,name=task_requests,json=taskRequests,proto3" json:"task_requests,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

var xxx_messageInfo_CrossClusterTaskRequests proto.InternalMessageInfo

func (m *CrossClusterTaskRequests) GetTaskRequests() []*CrossClusterTaskRequest {
	if m != nil {
		return m.TaskRequests
	}
	return nil
}

func init() {
	proto.RegisterEnum("uber.cadence.admin.v1.TaskType", TaskType_name, TaskType_value)
	proto.RegisterEnum("uber.cadence.admin.v1.CrossClusterTaskType", CrossClusterTaskType_name, CrossClusterTaskType_value)
	proto.RegisterEnum("uber.cadence.admin.v1.CrossClusterTaskFailedCause", CrossClusterTaskFailedCause_name, CrossClusterTaskFailedCause_value)
	proto.RegisterEnum("uber.cadence.admin.v1.GetTaskFailedCause", GetTaskFailedCause_name, GetTaskFailedCause_value)
	proto.RegisterType((*CrossClusterTaskInfo)(nil), "uber.cadence.admin.v1.CrossClusterTaskInfo")
	proto.RegisterType((*CrossClusterStartChildExecutionRequestAttributes)(nil), "uber.cadence.admin.v1.CrossClusterStartChildExecutionRequestAttributes")
	proto.RegisterMapType((map[string]string)(nil), "uber.cadence.admin.v1.CrossClusterStartChildExecutionRequestAttributes.PartitionConfigEntry")
	proto.RegisterType((*CrossClusterStartChildExecutionResponseAttributes)(nil), "uber.cadence.admin.v1.CrossClusterStartChildExecutionResponseAttributes")
	proto.RegisterType((*CrossClusterCancelExecutionRequestAttributes)(nil), "uber.cadence.admin.v1.CrossClusterCancelExecutionRequestAttributes")
	proto.RegisterType((*CrossClusterCancelExecutionResponseAttributes)(nil), "uber.cadence.admin.v1.CrossClusterCancelExecutionResponseAttributes")
	proto.RegisterType((*CrossClusterSignalExecutionRequestAttributes)(nil), "uber.cadence.admin.v1.CrossClusterSignalExecutionRequestAttributes")
	proto.RegisterType((*CrossClusterSignalExecutionResponseAttributes)(nil), "uber.cadence.admin.v1.CrossClusterSignalExecutionResponseAttributes")
	proto.RegisterType((*CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes)(nil), "uber.cadence.admin.v1.CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes")
	proto.RegisterType((*CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes)(nil), "uber.cadence.admin.v1.CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes")
	proto.RegisterType((*ApplyParentClosePolicyAttributes)(nil), "uber.cadence.admin.v1.ApplyParentClosePolicyAttributes")
	proto.RegisterType((*ApplyParentClosePolicyStatus)(nil), "uber.cadence.admin.v1.ApplyParentClosePolicyStatus")
	proto.RegisterType((*ApplyParentClosePolicyRequest)(nil), "uber.cadence.admin.v1.ApplyParentClosePolicyRequest")
	proto.RegisterType((*CrossClusterApplyParentClosePolicyRequestAttributes)(nil), "uber.cadence.admin.v1.CrossClusterApplyParentClosePolicyRequestAttributes")
	proto.RegisterType((*ApplyParentClosePolicyResult)(nil), "uber.cadence.admin.v1.ApplyParentClosePolicyResult")
	proto.RegisterType((*CrossClusterApplyParentClosePolicyResponseAttributes)(nil), "uber.cadence.admin.v1.CrossClusterApplyParentClosePolicyResponseAttributes")
	proto.RegisterType((*CrossClusterTaskRequest)(nil), "uber.cadence.admin.v1.CrossClusterTaskRequest")
	proto.RegisterType((*CrossClusterTaskResponse)(nil), "uber.cadence.admin.v1.CrossClusterTaskResponse")
	proto.RegisterType((*CrossClusterTaskRequests)(nil), "uber.cadence.admin.v1.CrossClusterTaskRequests")
}

func init() { proto.RegisterFile("uber/cadence/admin/v1/queue.proto", fileDescriptor_8d7963584a31be0a) }

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

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

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

func (m *CrossClusterTaskInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.VisibilityTimestamp != nil {
		{
			size, err := m.VisibilityTimestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.TaskId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskId))
		i--
		dAtA[i] = 0x28
	}
	if m.TaskState != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskState))
		i--
		dAtA[i] = 0x20
	}
	if m.TaskType != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskType))
		i--
		dAtA[i] = 0x18
	}
	if m.WorkflowExecution != nil {
		{
			size, err := m.WorkflowExecution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.DomainId) > 0 {
		i -= len(m.DomainId)
		copy(dAtA[i:], m.DomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.DomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterStartChildExecutionRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.PartitionConfig) > 0 {
		for k := range m.PartitionConfig {
			v := m.PartitionConfig[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.TargetRunId) > 0 {
		i -= len(m.TargetRunId)
		copy(dAtA[i:], m.TargetRunId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.TargetRunId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.InitiatedEventAttributes != nil {
		{
			size, err := m.InitiatedEventAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.InitiatedEventId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.InitiatedEventId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.RequestId) > 0 {
		i -= len(m.RequestId)
		copy(dAtA[i:], m.RequestId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.RequestId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TargetDomainId) > 0 {
		i -= len(m.TargetDomainId)
		copy(dAtA[i:], m.TargetDomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.TargetDomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CrossClusterCancelExecutionRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ChildWorkflowOnly {
		i--
		if m.ChildWorkflowOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.InitiatedEventId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.InitiatedEventId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RequestId) > 0 {
		i -= len(m.RequestId)
		copy(dAtA[i:], m.RequestId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.RequestId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TargetWorkflowExecution != nil {
		{
			size, err := m.TargetWorkflowExecution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.TargetDomainId) > 0 {
		i -= len(m.TargetDomainId)
		copy(dAtA[i:], m.TargetDomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.TargetDomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterCancelExecutionResponseAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterSignalExecutionRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Control) > 0 {
		i -= len(m.Control)
		copy(dAtA[i:], m.Control)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Control)))
		i--
		dAtA[i] = 0x42
	}
	if m.SignalInput != nil {
		{
			size, err := m.SignalInput.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.SignalName) > 0 {
		i -= len(m.SignalName)
		copy(dAtA[i:], m.SignalName)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.SignalName)))
		i--
		dAtA[i] = 0x32
	}
	if m.ChildWorkflowOnly {
		i--
		if m.ChildWorkflowOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.InitiatedEventId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.InitiatedEventId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RequestId) > 0 {
		i -= len(m.RequestId)
		copy(dAtA[i:], m.RequestId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.RequestId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TargetWorkflowExecution != nil {
		{
			size, err := m.TargetWorkflowExecution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.TargetDomainId) > 0 {
		i -= len(m.TargetDomainId)
		copy(dAtA[i:], m.TargetDomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.TargetDomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterSignalExecutionResponseAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CompletionEvent != nil {
		{
			size, err := m.CompletionEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.InitiatedEventId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.InitiatedEventId))
		i--
		dAtA[i] = 0x18
	}
	if m.TargetWorkflowExecution != nil {
		{
			size, err := m.TargetWorkflowExecution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.TargetDomainId) > 0 {
		i -= len(m.TargetDomainId)
		copy(dAtA[i:], m.TargetDomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.TargetDomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ApplyParentClosePolicyAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ParentClosePolicy != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.ParentClosePolicy))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ChildRunId) > 0 {
		i -= len(m.ChildRunId)
		copy(dAtA[i:], m.ChildRunId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ChildRunId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ChildWorkflowId) > 0 {
		i -= len(m.ChildWorkflowId)
		copy(dAtA[i:], m.ChildWorkflowId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ChildWorkflowId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChildDomainId) > 0 {
		i -= len(m.ChildDomainId)
		copy(dAtA[i:], m.ChildDomainId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ChildDomainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ApplyParentClosePolicyStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FailedCause != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.FailedCause))
		i--
		dAtA[i] = 0x10
	}
	if m.Completed {
		i--
		if m.Completed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ApplyParentClosePolicyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Child != nil {
		{
			size, err := m.Child.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ApplyParentClosePolicyResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FailedCause != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.FailedCause))
		i--
		dAtA[i] = 0x10
	}
	if m.Child != nil {
		{
			size, err := m.Child.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CrossClusterTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Attributes != nil {
		{
			size := m.Attributes.Size()
			i -= size
			if _, err := m.Attributes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.TaskInfo != nil {
		{
			size, err := m.TaskInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CrossClusterTaskRequest_StartChildExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StartChildExecutionAttributes != nil {
		{
			size, err := m.StartChildExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskRequest_CancelExecutionAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskRequest_CancelExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CancelExecutionAttributes != nil {
		{
			size, err := m.CancelExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskRequest_SignalExecutionAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskRequest_SignalExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignalExecutionAttributes != nil {
		{
			size, err := m.SignalExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RecordChildWorkflowExecutionCompleteRequestAttributes != nil {
		{
			size, err := m.RecordChildWorkflowExecutionCompleteRequestAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ApplyParentClosePolicyRequestAttributes != nil {
		{
			size, err := m.ApplyParentClosePolicyRequestAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *CrossClusterTaskResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Attributes != nil {
		{
			size := m.Attributes.Size()
			i -= size
			if _, err := m.Attributes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.FailedCause != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.FailedCause))
		i--
		dAtA[i] = 0x20
	}
	if m.TaskState != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskState))
		i--
		dAtA[i] = 0x18
	}
	if m.TaskType != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskType))
		i--
		dAtA[i] = 0x10
	}
	if m.TaskId != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.TaskId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CrossClusterTaskResponse_StartChildExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StartChildExecutionAttributes != nil {
		{
			size, err := m.StartChildExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskResponse_CancelExecutionAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskResponse_CancelExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CancelExecutionAttributes != nil {
		{
			size, err := m.CancelExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskResponse_SignalExecutionAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskResponse_SignalExecutionAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignalExecutionAttributes != nil {
		{
			size, err := m.SignalExecutionAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RecordChildWorkflowExecutionCompleteRequestAttributes != nil {
		{
			size, err := m.RecordChildWorkflowExecutionCompleteRequestAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ApplyParentClosePolicyResponseAttributes != nil {
		{
			size, err := m.ApplyParentClosePolicyResponseAttributes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *CrossClusterTaskRequests) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

func encodeVarintQueue(dAtA []byte, offset int, v uint64) int {
	offset -= sovQueue(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CrossClusterTaskInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.WorkflowExecution != nil {
		l = m.WorkflowExecution.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.TaskType != 0 {
		n += 1 + sovQueue(uint64(m.TaskType))
	}
	if m.TaskState != 0 {
		n += 1 + sovQueue(uint64(m.TaskState))
	}
	if m.TaskId != 0 {
		n += 1 + sovQueue(uint64(m.TaskId))
	}
	if m.VisibilityTimestamp != nil {
		l = m.VisibilityTimestamp.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterStartChildExecutionRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetDomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.RequestId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.InitiatedEventId != 0 {
		n += 1 + sovQueue(uint64(m.InitiatedEventId))
	}
	if m.InitiatedEventAttributes != nil {
		l = m.InitiatedEventAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.TargetRunId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.PartitionConfig) > 0 {
		for k, v := range m.PartitionConfig {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterStartChildExecutionResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RunId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterCancelExecutionRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetDomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.TargetWorkflowExecution != nil {
		l = m.TargetWorkflowExecution.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.RequestId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.InitiatedEventId != 0 {
		n += 1 + sovQueue(uint64(m.InitiatedEventId))
	}
	if m.ChildWorkflowOnly {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterCancelExecutionResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterSignalExecutionRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetDomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.TargetWorkflowExecution != nil {
		l = m.TargetWorkflowExecution.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.RequestId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.InitiatedEventId != 0 {
		n += 1 + sovQueue(uint64(m.InitiatedEventId))
	}
	if m.ChildWorkflowOnly {
		n += 2
	}
	l = len(m.SignalName)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.SignalInput != nil {
		l = m.SignalInput.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Control)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterSignalExecutionResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetDomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.TargetWorkflowExecution != nil {
		l = m.TargetWorkflowExecution.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.InitiatedEventId != 0 {
		n += 1 + sovQueue(uint64(m.InitiatedEventId))
	}
	if m.CompletionEvent != nil {
		l = m.CompletionEvent.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ApplyParentClosePolicyAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChildDomainId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.ChildWorkflowId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.ChildRunId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.ParentClosePolicy != 0 {
		n += 1 + sovQueue(uint64(m.ParentClosePolicy))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ApplyParentClosePolicyStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Completed {
		n += 2
	}
	if m.FailedCause != 0 {
		n += 1 + sovQueue(uint64(m.FailedCause))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ApplyParentClosePolicyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Child != nil {
		l = m.Child.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterApplyParentClosePolicyRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Children) > 0 {
		for _, e := range m.Children {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ApplyParentClosePolicyResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Child != nil {
		l = m.Child.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.FailedCause != 0 {
		n += 1 + sovQueue(uint64(m.FailedCause))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterApplyParentClosePolicyResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ChildrenStatus) > 0 {
		for _, e := range m.ChildrenStatus {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterTaskRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TaskInfo != nil {
		l = m.TaskInfo.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.Attributes != nil {
		n += m.Attributes.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterTaskRequest_StartChildExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartChildExecutionAttributes != nil {
		l = m.StartChildExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskRequest_CancelExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CancelExecutionAttributes != nil {
		l = m.CancelExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskRequest_SignalExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignalExecutionAttributes != nil {
		l = m.SignalExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecordChildWorkflowExecutionCompleteRequestAttributes != nil {
		l = m.RecordChildWorkflowExecutionCompleteRequestAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ApplyParentClosePolicyRequestAttributes != nil {
		l = m.ApplyParentClosePolicyRequestAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TaskId != 0 {
		n += 1 + sovQueue(uint64(m.TaskId))
	}
	if m.TaskType != 0 {
		n += 1 + sovQueue(uint64(m.TaskType))
	}
	if m.TaskState != 0 {
		n += 1 + sovQueue(uint64(m.TaskState))
	}
	if m.FailedCause != 0 {
		n += 1 + sovQueue(uint64(m.FailedCause))
	}
	if m.Attributes != nil {
		n += m.Attributes.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CrossClusterTaskResponse_StartChildExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartChildExecutionAttributes != nil {
		l = m.StartChildExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskResponse_CancelExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CancelExecutionAttributes != nil {
		l = m.CancelExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskResponse_SignalExecutionAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignalExecutionAttributes != nil {
		l = m.SignalExecutionAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecordChildWorkflowExecutionCompleteRequestAttributes != nil {
		l = m.RecordChildWorkflowExecutionCompleteRequestAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ApplyParentClosePolicyResponseAttributes != nil {
		l = m.ApplyParentClosePolicyResponseAttributes.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}
func (m *CrossClusterTaskRequests) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TaskRequests) > 0 {
		for _, e := range m.TaskRequests {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovQueue(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQueue(x uint64) (n int) {
	return sovQueue(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CrossClusterTaskInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterTaskInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterTaskInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DomainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DomainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowExecution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WorkflowExecution == nil {
				m.WorkflowExecution = &v1.WorkflowExecution{}
			}
			if err := m.WorkflowExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskType", wireType)
			}
			m.TaskType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskType |= CrossClusterTaskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskState", wireType)
			}
			m.TaskState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskState |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
			}
			m.TaskId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VisibilityTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VisibilityTimestamp == nil {
				m.VisibilityTimestamp = &types.Timestamp{}
			}
			if err := m.VisibilityTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossClusterStartChildExecutionRequestAttributes) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterStartChildExecutionRequestAttributes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterStartChildExecutionRequestAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetDomainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetDomainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitiatedEventId", wireType)
			}
			m.InitiatedEventId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InitiatedEventId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitiatedEventAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InitiatedEventAttributes == nil {
				m.InitiatedEventAttributes = &v1.StartChildWorkflowExecutionInitiatedEventAttributes{}
			}
			if err := m.InitiatedEventAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetRunId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetRunId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PartitionConfig == nil {
				m.PartitionConfig = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.PartitionConfig[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossClusterCancelExecutionRequestAttributes) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterCancelExecutionRequestAttributes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterCancelExecutionRequestAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetDomainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetDomainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetWorkflowExecution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetWorkflowExecution == nil {
				m.TargetWorkflowExecution = &v1.WorkflowExecution{}
			}
			if err := m.TargetWorkflowExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitiatedEventId", wireType)
			}
			m.InitiatedEventId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InitiatedEventId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildWorkflowOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ChildWorkflowOnly = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossClusterSignalExecutionRequestAttributes) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterSignalExecutionRequestAttributes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterSignalExecutionRequestAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetDomainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetDomainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetWorkflowExecution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetWorkflowExecution == nil {
				m.TargetWorkflowExecution = &v1.WorkflowExecution{}
			}
			if err := m.TargetWorkflowExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitiatedEventId", wireType)
			}
			m.InitiatedEventId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InitiatedEventId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildWorkflowOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ChildWorkflowOnly = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalInput", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SignalInput == nil {
				m.SignalInput = &v1.Payload{}
			}
			if err := m.SignalInput.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Control", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Control = append(m.Control[:0], dAtA[iNdEx:postIndex]...)
			if m.Control == nil {
				m.Control = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossClusterTaskRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterTaskRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TaskInfo == nil {
				m.TaskInfo = &CrossClusterTaskInfo{}
			}
			if err := m.TaskInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartChildExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterStartChildExecutionRequestAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskRequest_StartChildExecutionAttributes{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterCancelExecutionRequestAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskRequest_CancelExecutionAttributes{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterSignalExecutionRequestAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskRequest_SignalExecutionAttributes{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordChildWorkflowExecutionCompleteRequestAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterRecordChildWorkflowExecutionCompleteRequestAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskRequest_RecordChildWorkflowExecutionCompleteRequestAttributes{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplyParentClosePolicyRequestAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterApplyParentClosePolicyRequestAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskRequest_ApplyParentClosePolicyRequestAttributes{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossClusterTaskResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQueue
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CrossClusterTaskResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossClusterTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
			}
			m.TaskId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskType", wireType)
			}
			m.TaskType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskType |= CrossClusterTaskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskState", wireType)
			}
			m.TaskState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskState |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailedCause", wireType)
			}
			m.FailedCause = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FailedCause |= CrossClusterTaskFailedCause(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartChildExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterStartChildExecutionResponseAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskResponse_StartChildExecutionAttributes{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterCancelExecutionResponseAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskResponse_CancelExecutionAttributes{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalExecutionAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterSignalExecutionResponseAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskResponse_SignalExecutionAttributes{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordChildWorkflowExecutionCompleteRequestAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterRecordChildWorkflowExecutionCompleteResponseAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskResponse_RecordChildWorkflowExecutionCompleteRequestAttributes{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplyParentClosePolicyResponseAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CrossClusterApplyParentClosePolicyResponseAttributes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Attributes = &CrossClusterTaskResponse_ApplyParentClosePolicyResponseAttributes{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthQueue        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQueue          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQueue = fmt.Errorf("proto: unexpected end of group")
)