cron-workflow.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/apiclient/cronworkflow/cron-workflow.proto

package cronworkflow

import (
	context "context"
	fmt "fmt"
	v1alpha1 "github.com/kubework/work/pkg/apis/workflow/v1alpha1"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	_ "k8s.io/api/core/v1"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	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 LintCronWorkflowRequest struct {
	Namespace            string                 `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	CronWorkflow         *v1alpha1.CronWorkflow `protobuf:"bytes,2,opt,name=cronWorkflow,proto3" json:"cronWorkflow,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *LintCronWorkflowRequest) Reset()         { *m = LintCronWorkflowRequest{} }
func (m *LintCronWorkflowRequest) String() string { return proto.CompactTextString(m) }
func (*LintCronWorkflowRequest) ProtoMessage()    {}
func (*LintCronWorkflowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{0}
}
func (m *LintCronWorkflowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LintCronWorkflowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LintCronWorkflowRequest.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 *LintCronWorkflowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LintCronWorkflowRequest.Merge(m, src)
}
func (m *LintCronWorkflowRequest) XXX_Size() int {
	return m.Size()
}
func (m *LintCronWorkflowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LintCronWorkflowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LintCronWorkflowRequest proto.InternalMessageInfo

func (m *LintCronWorkflowRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *LintCronWorkflowRequest) GetCronWorkflow() *v1alpha1.CronWorkflow {
	if m != nil {
		return m.CronWorkflow
	}
	return nil
}

type CreateCronWorkflowRequest struct {
	Namespace            string                 `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	CronWorkflow         *v1alpha1.CronWorkflow `protobuf:"bytes,2,opt,name=cronWorkflow,proto3" json:"cronWorkflow,omitempty"`
	CreateOptions        *v1.CreateOptions      `protobuf:"bytes,3,opt,name=createOptions,proto3" json:"createOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *CreateCronWorkflowRequest) Reset()         { *m = CreateCronWorkflowRequest{} }
func (m *CreateCronWorkflowRequest) String() string { return proto.CompactTextString(m) }
func (*CreateCronWorkflowRequest) ProtoMessage()    {}
func (*CreateCronWorkflowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{1}
}
func (m *CreateCronWorkflowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateCronWorkflowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateCronWorkflowRequest.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 *CreateCronWorkflowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateCronWorkflowRequest.Merge(m, src)
}
func (m *CreateCronWorkflowRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateCronWorkflowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateCronWorkflowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateCronWorkflowRequest proto.InternalMessageInfo

func (m *CreateCronWorkflowRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *CreateCronWorkflowRequest) GetCronWorkflow() *v1alpha1.CronWorkflow {
	if m != nil {
		return m.CronWorkflow
	}
	return nil
}

func (m *CreateCronWorkflowRequest) GetCreateOptions() *v1.CreateOptions {
	if m != nil {
		return m.CreateOptions
	}
	return nil
}

type ListCronWorkflowsRequest struct {
	Namespace            string          `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ListOptions          *v1.ListOptions `protobuf:"bytes,2,opt,name=listOptions,proto3" json:"listOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ListCronWorkflowsRequest) Reset()         { *m = ListCronWorkflowsRequest{} }
func (m *ListCronWorkflowsRequest) String() string { return proto.CompactTextString(m) }
func (*ListCronWorkflowsRequest) ProtoMessage()    {}
func (*ListCronWorkflowsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{2}
}
func (m *ListCronWorkflowsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListCronWorkflowsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListCronWorkflowsRequest.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 *ListCronWorkflowsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListCronWorkflowsRequest.Merge(m, src)
}
func (m *ListCronWorkflowsRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListCronWorkflowsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListCronWorkflowsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListCronWorkflowsRequest proto.InternalMessageInfo

func (m *ListCronWorkflowsRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ListCronWorkflowsRequest) GetListOptions() *v1.ListOptions {
	if m != nil {
		return m.ListOptions
	}
	return nil
}

type GetCronWorkflowRequest struct {
	Name                 string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string         `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	GetOptions           *v1.GetOptions `protobuf:"bytes,3,opt,name=getOptions,proto3" json:"getOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *GetCronWorkflowRequest) Reset()         { *m = GetCronWorkflowRequest{} }
func (m *GetCronWorkflowRequest) String() string { return proto.CompactTextString(m) }
func (*GetCronWorkflowRequest) ProtoMessage()    {}
func (*GetCronWorkflowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{3}
}
func (m *GetCronWorkflowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetCronWorkflowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetCronWorkflowRequest.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 *GetCronWorkflowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCronWorkflowRequest.Merge(m, src)
}
func (m *GetCronWorkflowRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetCronWorkflowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCronWorkflowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetCronWorkflowRequest proto.InternalMessageInfo

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

func (m *GetCronWorkflowRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *GetCronWorkflowRequest) GetGetOptions() *v1.GetOptions {
	if m != nil {
		return m.GetOptions
	}
	return nil
}

type UpdateCronWorkflowRequest struct {
	Name                 string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string                 `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	CronWorkflow         *v1alpha1.CronWorkflow `protobuf:"bytes,3,opt,name=cronWorkflow,proto3" json:"cronWorkflow,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *UpdateCronWorkflowRequest) Reset()         { *m = UpdateCronWorkflowRequest{} }
func (m *UpdateCronWorkflowRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateCronWorkflowRequest) ProtoMessage()    {}
func (*UpdateCronWorkflowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{4}
}
func (m *UpdateCronWorkflowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateCronWorkflowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateCronWorkflowRequest.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 *UpdateCronWorkflowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateCronWorkflowRequest.Merge(m, src)
}
func (m *UpdateCronWorkflowRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateCronWorkflowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateCronWorkflowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateCronWorkflowRequest proto.InternalMessageInfo

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

func (m *UpdateCronWorkflowRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *UpdateCronWorkflowRequest) GetCronWorkflow() *v1alpha1.CronWorkflow {
	if m != nil {
		return m.CronWorkflow
	}
	return nil
}

type DeleteCronWorkflowRequest struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace            string            `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	DeleteOptions        *v1.DeleteOptions `protobuf:"bytes,3,opt,name=deleteOptions,proto3" json:"deleteOptions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DeleteCronWorkflowRequest) Reset()         { *m = DeleteCronWorkflowRequest{} }
func (m *DeleteCronWorkflowRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteCronWorkflowRequest) ProtoMessage()    {}
func (*DeleteCronWorkflowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{5}
}
func (m *DeleteCronWorkflowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteCronWorkflowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteCronWorkflowRequest.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 *DeleteCronWorkflowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteCronWorkflowRequest.Merge(m, src)
}
func (m *DeleteCronWorkflowRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteCronWorkflowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteCronWorkflowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteCronWorkflowRequest proto.InternalMessageInfo

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

func (m *DeleteCronWorkflowRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *DeleteCronWorkflowRequest) GetDeleteOptions() *v1.DeleteOptions {
	if m != nil {
		return m.DeleteOptions
	}
	return nil
}

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

func (m *CronWorkflowDeletedResponse) Reset()         { *m = CronWorkflowDeletedResponse{} }
func (m *CronWorkflowDeletedResponse) String() string { return proto.CompactTextString(m) }
func (*CronWorkflowDeletedResponse) ProtoMessage()    {}
func (*CronWorkflowDeletedResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_257f310938c448f8, []int{6}
}
func (m *CronWorkflowDeletedResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CronWorkflowDeletedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CronWorkflowDeletedResponse.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 *CronWorkflowDeletedResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CronWorkflowDeletedResponse.Merge(m, src)
}
func (m *CronWorkflowDeletedResponse) XXX_Size() int {
	return m.Size()
}
func (m *CronWorkflowDeletedResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CronWorkflowDeletedResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CronWorkflowDeletedResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*LintCronWorkflowRequest)(nil), "cronworkflow.LintCronWorkflowRequest")
	proto.RegisterType((*CreateCronWorkflowRequest)(nil), "cronworkflow.CreateCronWorkflowRequest")
	proto.RegisterType((*ListCronWorkflowsRequest)(nil), "cronworkflow.ListCronWorkflowsRequest")
	proto.RegisterType((*GetCronWorkflowRequest)(nil), "cronworkflow.GetCronWorkflowRequest")
	proto.RegisterType((*UpdateCronWorkflowRequest)(nil), "cronworkflow.UpdateCronWorkflowRequest")
	proto.RegisterType((*DeleteCronWorkflowRequest)(nil), "cronworkflow.DeleteCronWorkflowRequest")
	proto.RegisterType((*CronWorkflowDeletedResponse)(nil), "cronworkflow.CronWorkflowDeletedResponse")
}

func init() {
	proto.RegisterFile("pkg/apiclient/cronworkflow/cron-workflow.proto", fileDescriptor_257f310938c448f8)
}

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

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

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

// CronWorkflowServiceClient is the client API for CronWorkflowService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CronWorkflowServiceClient interface {
	LintCronWorkflow(ctx context.Context, in *LintCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error)
	CreateCronWorkflow(ctx context.Context, in *CreateCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error)
	ListCronWorkflows(ctx context.Context, in *ListCronWorkflowsRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflowList, error)
	GetCronWorkflow(ctx context.Context, in *GetCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error)
	UpdateCronWorkflow(ctx context.Context, in *UpdateCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error)
	DeleteCronWorkflow(ctx context.Context, in *DeleteCronWorkflowRequest, opts ...grpc.CallOption) (*CronWorkflowDeletedResponse, error)
}

type cronWorkflowServiceClient struct {
	cc *grpc.ClientConn
}

func NewCronWorkflowServiceClient(cc *grpc.ClientConn) CronWorkflowServiceClient {
	return &cronWorkflowServiceClient{cc}
}

func (c *cronWorkflowServiceClient) LintCronWorkflow(ctx context.Context, in *LintCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error) {
	out := new(v1alpha1.CronWorkflow)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/LintCronWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronWorkflowServiceClient) CreateCronWorkflow(ctx context.Context, in *CreateCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error) {
	out := new(v1alpha1.CronWorkflow)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/CreateCronWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronWorkflowServiceClient) ListCronWorkflows(ctx context.Context, in *ListCronWorkflowsRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflowList, error) {
	out := new(v1alpha1.CronWorkflowList)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/ListCronWorkflows", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronWorkflowServiceClient) GetCronWorkflow(ctx context.Context, in *GetCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error) {
	out := new(v1alpha1.CronWorkflow)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/GetCronWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronWorkflowServiceClient) UpdateCronWorkflow(ctx context.Context, in *UpdateCronWorkflowRequest, opts ...grpc.CallOption) (*v1alpha1.CronWorkflow, error) {
	out := new(v1alpha1.CronWorkflow)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/UpdateCronWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cronWorkflowServiceClient) DeleteCronWorkflow(ctx context.Context, in *DeleteCronWorkflowRequest, opts ...grpc.CallOption) (*CronWorkflowDeletedResponse, error) {
	out := new(CronWorkflowDeletedResponse)
	err := c.cc.Invoke(ctx, "/cronworkflow.CronWorkflowService/DeleteCronWorkflow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CronWorkflowServiceServer is the server API for CronWorkflowService service.
type CronWorkflowServiceServer interface {
	LintCronWorkflow(context.Context, *LintCronWorkflowRequest) (*v1alpha1.CronWorkflow, error)
	CreateCronWorkflow(context.Context, *CreateCronWorkflowRequest) (*v1alpha1.CronWorkflow, error)
	ListCronWorkflows(context.Context, *ListCronWorkflowsRequest) (*v1alpha1.CronWorkflowList, error)
	GetCronWorkflow(context.Context, *GetCronWorkflowRequest) (*v1alpha1.CronWorkflow, error)
	UpdateCronWorkflow(context.Context, *UpdateCronWorkflowRequest) (*v1alpha1.CronWorkflow, error)
	DeleteCronWorkflow(context.Context, *DeleteCronWorkflowRequest) (*CronWorkflowDeletedResponse, error)
}

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

func (*UnimplementedCronWorkflowServiceServer) LintCronWorkflow(ctx context.Context, req *LintCronWorkflowRequest) (*v1alpha1.CronWorkflow, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LintCronWorkflow not implemented")
}
func (*UnimplementedCronWorkflowServiceServer) CreateCronWorkflow(ctx context.Context, req *CreateCronWorkflowRequest) (*v1alpha1.CronWorkflow, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCronWorkflow not implemented")
}
func (*UnimplementedCronWorkflowServiceServer) ListCronWorkflows(ctx context.Context, req *ListCronWorkflowsRequest) (*v1alpha1.CronWorkflowList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCronWorkflows not implemented")
}
func (*UnimplementedCronWorkflowServiceServer) GetCronWorkflow(ctx context.Context, req *GetCronWorkflowRequest) (*v1alpha1.CronWorkflow, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCronWorkflow not implemented")
}
func (*UnimplementedCronWorkflowServiceServer) UpdateCronWorkflow(ctx context.Context, req *UpdateCronWorkflowRequest) (*v1alpha1.CronWorkflow, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCronWorkflow not implemented")
}
func (*UnimplementedCronWorkflowServiceServer) DeleteCronWorkflow(ctx context.Context, req *DeleteCronWorkflowRequest) (*CronWorkflowDeletedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCronWorkflow not implemented")
}

func RegisterCronWorkflowServiceServer(s *grpc.Server, srv CronWorkflowServiceServer) {
	s.RegisterService(&_CronWorkflowService_serviceDesc, srv)
}

func _CronWorkflowService_LintCronWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LintCronWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).LintCronWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/LintCronWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).LintCronWorkflow(ctx, req.(*LintCronWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronWorkflowService_CreateCronWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCronWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).CreateCronWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/CreateCronWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).CreateCronWorkflow(ctx, req.(*CreateCronWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronWorkflowService_ListCronWorkflows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCronWorkflowsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).ListCronWorkflows(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/ListCronWorkflows",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).ListCronWorkflows(ctx, req.(*ListCronWorkflowsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronWorkflowService_GetCronWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCronWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).GetCronWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/GetCronWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).GetCronWorkflow(ctx, req.(*GetCronWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronWorkflowService_UpdateCronWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCronWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).UpdateCronWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/UpdateCronWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).UpdateCronWorkflow(ctx, req.(*UpdateCronWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CronWorkflowService_DeleteCronWorkflow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteCronWorkflowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CronWorkflowServiceServer).DeleteCronWorkflow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cronworkflow.CronWorkflowService/DeleteCronWorkflow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CronWorkflowServiceServer).DeleteCronWorkflow(ctx, req.(*DeleteCronWorkflowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CronWorkflowService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cronworkflow.CronWorkflowService",
	HandlerType: (*CronWorkflowServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "LintCronWorkflow",
			Handler:    _CronWorkflowService_LintCronWorkflow_Handler,
		},
		{
			MethodName: "CreateCronWorkflow",
			Handler:    _CronWorkflowService_CreateCronWorkflow_Handler,
		},
		{
			MethodName: "ListCronWorkflows",
			Handler:    _CronWorkflowService_ListCronWorkflows_Handler,
		},
		{
			MethodName: "GetCronWorkflow",
			Handler:    _CronWorkflowService_GetCronWorkflow_Handler,
		},
		{
			MethodName: "UpdateCronWorkflow",
			Handler:    _CronWorkflowService_UpdateCronWorkflow_Handler,
		},
		{
			MethodName: "DeleteCronWorkflow",
			Handler:    _CronWorkflowService_DeleteCronWorkflow_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/apiclient/cronworkflow/cron-workflow.proto",
}

func (m *LintCronWorkflowRequest) 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 *LintCronWorkflowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LintCronWorkflowRequest) 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.CronWorkflow != nil {
		{
			size, err := m.CronWorkflow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateCronWorkflowRequest) 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 *CreateCronWorkflowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateCronWorkflowRequest) 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.CreateOptions != nil {
		{
			size, err := m.CreateOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.CronWorkflow != nil {
		{
			size, err := m.CronWorkflow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ListCronWorkflowsRequest) 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 *ListCronWorkflowsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListCronWorkflowsRequest) 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.ListOptions != nil {
		{
			size, err := m.ListOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetCronWorkflowRequest) 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 *GetCronWorkflowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetCronWorkflowRequest) 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.GetOptions != nil {
		{
			size, err := m.GetOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UpdateCronWorkflowRequest) 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 *UpdateCronWorkflowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateCronWorkflowRequest) 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.CronWorkflow != nil {
		{
			size, err := m.CronWorkflow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteCronWorkflowRequest) 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 *DeleteCronWorkflowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteCronWorkflowRequest) 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.DeleteOptions != nil {
		{
			size, err := m.DeleteOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCronWorkflow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCronWorkflow(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CronWorkflowDeletedResponse) 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 *CronWorkflowDeletedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CronWorkflowDeletedResponse) 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 encodeVarintCronWorkflow(dAtA []byte, offset int, v uint64) int {
	offset -= sovCronWorkflow(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *LintCronWorkflowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.CronWorkflow != nil {
		l = m.CronWorkflow.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateCronWorkflowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.CronWorkflow != nil {
		l = m.CronWorkflow.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.CreateOptions != nil {
		l = m.CreateOptions.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListCronWorkflowsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.ListOptions != nil {
		l = m.ListOptions.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetCronWorkflowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.GetOptions != nil {
		l = m.GetOptions.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateCronWorkflowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.CronWorkflow != nil {
		l = m.CronWorkflow.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteCronWorkflowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.DeleteOptions != nil {
		l = m.DeleteOptions.Size()
		n += 1 + l + sovCronWorkflow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CronWorkflowDeletedResponse) 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 sovCronWorkflow(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCronWorkflow(x uint64) (n int) {
	return sovCronWorkflow(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *LintCronWorkflowRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: LintCronWorkflowRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LintCronWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronWorkflow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CronWorkflow == nil {
				m.CronWorkflow = &v1alpha1.CronWorkflow{}
			}
			if err := m.CronWorkflow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *CreateCronWorkflowRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: CreateCronWorkflowRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateCronWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronWorkflow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CronWorkflow == nil {
				m.CronWorkflow = &v1alpha1.CronWorkflow{}
			}
			if err := m.CronWorkflow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreateOptions == nil {
				m.CreateOptions = &v1.CreateOptions{}
			}
			if err := m.CreateOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *ListCronWorkflowsRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: ListCronWorkflowsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListCronWorkflowsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ListOptions == nil {
				m.ListOptions = &v1.ListOptions{}
			}
			if err := m.ListOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *GetCronWorkflowRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: GetCronWorkflowRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetCronWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetOptions == nil {
				m.GetOptions = &v1.GetOptions{}
			}
			if err := m.GetOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *UpdateCronWorkflowRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: UpdateCronWorkflowRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateCronWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronWorkflow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CronWorkflow == nil {
				m.CronWorkflow = &v1alpha1.CronWorkflow{}
			}
			if err := m.CronWorkflow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *DeleteCronWorkflowRequest) 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 ErrIntOverflowCronWorkflow
			}
			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: DeleteCronWorkflowRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteCronWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				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 ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCronWorkflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeleteOptions == nil {
				m.DeleteOptions = &v1.DeleteOptions{}
			}
			if err := m.DeleteOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 *CronWorkflowDeletedResponse) 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 ErrIntOverflowCronWorkflow
			}
			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: CronWorkflowDeletedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CronWorkflowDeletedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCronWorkflow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCronWorkflow
			}
			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 skipCronWorkflow(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, ErrIntOverflowCronWorkflow
			}
			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, ErrIntOverflowCronWorkflow
				}
				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, ErrIntOverflowCronWorkflow
				}
				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, ErrInvalidLengthCronWorkflow
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCronWorkflow
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCronWorkflow
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCronWorkflow        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCronWorkflow          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCronWorkflow = fmt.Errorf("proto: unexpected end of group")
)