scheduler.pb.go

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

package ccloud

import (
	fmt "fmt"
	_ "github.com/confluentinc/proto-go-setter"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	_ "github.com/travisjeffery/proto-go-sql"
	io "io"
	math "math"
	time "time"
)

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

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

type NetworkType int32

const (
	NetworkType_UNKNOWN_TYPE    NetworkType = 0
	NetworkType_PUBLIC          NetworkType = 1
	NetworkType_PRIVATE_LINK    NetworkType = 2
	NetworkType_TRANSIT_GATEWAY NetworkType = 3
	NetworkType_VPC_PEERING     NetworkType = 4
	// INTERNAL requires that source traffic origniates from the NetworkRegion's requested CIDR.
	NetworkType_INTERNAL                  NetworkType = 5
	NetworkType_PRIVATE_NETWORK_INTERFACE NetworkType = 6
)

var NetworkType_name = map[int32]string{
	0: "UNKNOWN_TYPE",
	1: "PUBLIC",
	2: "PRIVATE_LINK",
	3: "TRANSIT_GATEWAY",
	4: "VPC_PEERING",
	5: "INTERNAL",
	6: "PRIVATE_NETWORK_INTERFACE",
}

var NetworkType_value = map[string]int32{
	"UNKNOWN_TYPE":              0,
	"PUBLIC":                    1,
	"PRIVATE_LINK":              2,
	"TRANSIT_GATEWAY":           3,
	"VPC_PEERING":               4,
	"INTERNAL":                  5,
	"PRIVATE_NETWORK_INTERFACE": 6,
}

func (x NetworkType) String() string {
	return proto.EnumName(NetworkType_name, int32(x))
}

func (NetworkType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3d8db78ba60fec18, []int{0}
}

type GlobalSchemaRegistryLocation int32

const (
	GlobalSchemaRegistryLocation_NONE GlobalSchemaRegistryLocation = 0
	GlobalSchemaRegistryLocation_US   GlobalSchemaRegistryLocation = 1
	GlobalSchemaRegistryLocation_EU   GlobalSchemaRegistryLocation = 2
	GlobalSchemaRegistryLocation_APAC GlobalSchemaRegistryLocation = 3
)

var GlobalSchemaRegistryLocation_name = map[int32]string{
	0: "NONE",
	1: "US",
	2: "EU",
	3: "APAC",
}

var GlobalSchemaRegistryLocation_value = map[string]int32{
	"NONE": 0,
	"US":   1,
	"EU":   2,
	"APAC": 3,
}

func (x GlobalSchemaRegistryLocation) String() string {
	return proto.EnumName(GlobalSchemaRegistryLocation_name, int32(x))
}

func (GlobalSchemaRegistryLocation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3d8db78ba60fec18, []int{1}
}

type ClusterStatus int32

const (
	ClusterStatus_PROVISIONING      ClusterStatus = 0
	ClusterStatus_UP                ClusterStatus = 1
	ClusterStatus_DOWN              ClusterStatus = 2
	ClusterStatus_DELETING          ClusterStatus = 3
	ClusterStatus_DELETED           ClusterStatus = 4
	ClusterStatus_EXPANSION_PENDING ClusterStatus = 5
	ClusterStatus_EXPANDING         ClusterStatus = 6
	ClusterStatus_SHRINK_PENDING    ClusterStatus = 7
	ClusterStatus_SHRINKING         ClusterStatus = 8
	ClusterStatus_STORAGE_EXPANDING ClusterStatus = 9
)

var ClusterStatus_name = map[int32]string{
	0: "PROVISIONING",
	1: "UP",
	2: "DOWN",
	3: "DELETING",
	4: "DELETED",
	5: "EXPANSION_PENDING",
	6: "EXPANDING",
	7: "SHRINK_PENDING",
	8: "SHRINKING",
	9: "STORAGE_EXPANDING",
}

var ClusterStatus_value = map[string]int32{
	"PROVISIONING":      0,
	"UP":                1,
	"DOWN":              2,
	"DELETING":          3,
	"DELETED":           4,
	"EXPANSION_PENDING": 5,
	"EXPANDING":         6,
	"SHRINK_PENDING":    7,
	"SHRINKING":         8,
	"STORAGE_EXPANDING": 9,
}

func (x ClusterStatus) String() string {
	return proto.EnumName(ClusterStatus_name, int32(x))
}

func (ClusterStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3d8db78ba60fec18, []int{2}
}

type APICredentials struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" db:"key,omitempty" url:"key,omitempty"`
	Secret               string   `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty" redact:"-" db:"secret,omitempty" url:"secret,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_APICredentials proto.InternalMessageInfo

func (m *APICredentials) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *APICredentials) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

type Schedulability struct {
	SharedNetwork        *Schedulability_Tenancy `protobuf:"bytes,1,opt,name=shared_network,json=sharedNetwork,proto3" json:"shared_network,omitempty" db:"shared_network,omitempty" url:"shared_network,omitempty"`
	DedicatedNetwork     *Schedulability_Tenancy `protobuf:"bytes,2,opt,name=dedicated_network,json=dedicatedNetwork,proto3" json:"dedicated_network,omitempty" db:"dedicated_network,omitempty" url:"dedicated_network,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_Schedulability proto.InternalMessageInfo

func (m *Schedulability) GetSharedNetwork() *Schedulability_Tenancy {
	if m != nil {
		return m.SharedNetwork
	}
	return nil
}

func (m *Schedulability) GetDedicatedNetwork() *Schedulability_Tenancy {
	if m != nil {
		return m.DedicatedNetwork
	}
	return nil
}

type Schedulability_Tenancy struct {
	SharedCluster        *Schedulability_Tenancy_Durability `protobuf:"bytes,1,opt,name=shared_cluster,json=sharedCluster,proto3" json:"shared_cluster,omitempty" db:"shared_cluster,omitempty" url:"shared_cluster,omitempty"`
	DedicatedCluster     *Schedulability_Tenancy_Durability `protobuf:"bytes,2,opt,name=dedicated_cluster,json=dedicatedCluster,proto3" json:"dedicated_cluster,omitempty" db:"dedicated_cluster,omitempty" url:"dedicated_cluster,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

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

var xxx_messageInfo_Schedulability_Tenancy proto.InternalMessageInfo

func (m *Schedulability_Tenancy) GetSharedCluster() *Schedulability_Tenancy_Durability {
	if m != nil {
		return m.SharedCluster
	}
	return nil
}

func (m *Schedulability_Tenancy) GetDedicatedCluster() *Schedulability_Tenancy_Durability {
	if m != nil {
		return m.DedicatedCluster
	}
	return nil
}

type Schedulability_Tenancy_Durability struct {
	Low                  []NetworkType `protobuf:"varint,1,rep,packed,name=low,proto3,enum=ccloud.scheduler.NetworkType" json:"LOW" db:"low,omitempty" url:"low,omitempty"`
	High                 []NetworkType `protobuf:"varint,2,rep,packed,name=high,proto3,enum=ccloud.scheduler.NetworkType" json:"HIGH" db:"high,omitempty" url:"high,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Schedulability_Tenancy_Durability proto.InternalMessageInfo

func (m *Schedulability_Tenancy_Durability) GetLow() []NetworkType {
	if m != nil {
		return m.Low
	}
	return nil
}

func (m *Schedulability_Tenancy_Durability) GetHigh() []NetworkType {
	if m != nil {
		return m.High
	}
	return nil
}

type AvailabilityZone struct {
	// us-west-2
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"`
	// AWS:   zone id
	// GCP:   zone name
	// AZURE: zone name
	ZoneId string `protobuf:"bytes,3,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty" db:"zone_id,omitempty" url:"zone_id,omitempty"`
	// The internal mothership zone id
	Id                   string           `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"`
	RegionId             string           `protobuf:"bytes,5,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty" db:"region_id,omitempty" url:"region_id,omitempty"`
	SniEnabled           *types.BoolValue `protobuf:"bytes,6,opt,name=sni_enabled,json=sniEnabled,proto3" json:"sni_enabled,omitempty" db:"sni_enabled,omitempty" url:"sni_enabled,omitempty"`
	Schedulable          *types.BoolValue `protobuf:"bytes,7,opt,name=schedulable,proto3" json:"schedulable,omitempty" db:"schedulable,omitempty" url:"schedulable,omitempty"`
	Created              *time.Time       `protobuf:"bytes,8,opt,name=created,proto3,stdtime" json:"created,omitempty" db:"created,omitempty" url:"created,omitempty"`
	Modified             *time.Time       `protobuf:"bytes,9,opt,name=modified,proto3,stdtime" json:"modified,omitempty" db:"modified,omitempty" url:"modified,omitempty"`
	Deactivated          *time.Time       `protobuf:"bytes,10,opt,name=deactivated,proto3,stdtime" json:"deactivated,omitempty" db:"deactivated,omitempty" url:"deactivated,omitempty"`
	Realm                string           `protobuf:"bytes,12,opt,name=realm,proto3" json:"realm,omitempty" db:"realm,omitempty" url:"realm,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_AvailabilityZone proto.InternalMessageInfo

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

func (m *AvailabilityZone) GetZoneId() string {
	if m != nil {
		return m.ZoneId
	}
	return ""
}

func (m *AvailabilityZone) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *AvailabilityZone) GetRegionId() string {
	if m != nil {
		return m.RegionId
	}
	return ""
}

func (m *AvailabilityZone) GetSniEnabled() *types.BoolValue {
	if m != nil {
		return m.SniEnabled
	}
	return nil
}

func (m *AvailabilityZone) GetSchedulable() *types.BoolValue {
	if m != nil {
		return m.Schedulable
	}
	return nil
}

func (m *AvailabilityZone) GetCreated() *time.Time {
	if m != nil {
		return m.Created
	}
	return nil
}

func (m *AvailabilityZone) GetModified() *time.Time {
	if m != nil {
		return m.Modified
	}
	return nil
}

func (m *AvailabilityZone) GetDeactivated() *time.Time {
	if m != nil {
		return m.Deactivated
	}
	return nil
}

func (m *AvailabilityZone) GetRealm() string {
	if m != nil {
		return m.Realm
	}
	return ""
}

type Region struct {
	Id    string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"`
	Cloud string              `protobuf:"bytes,2,opt,name=cloud,proto3" json:"cloud,omitempty" db:"cloud,omitempty" url:"cloud,omitempty"`
	Zones []*AvailabilityZone `protobuf:"bytes,3,rep,name=zones,proto3" json:"zones,omitempty" db:"zones,omitempty" url:"zones,omitempty"`
	Name  string              `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"`
	// This field will be calcuated at runtime. Default to false
	// e.g. when there is available physical cluster for logical cluster provision, it will be set to true
	IsSchedulable bool `protobuf:"varint,5,opt,name=is_schedulable,json=isSchedulable,proto3" json:"is_schedulable,omitempty" db:"is_schedulable,omitempty" url:"is_schedulable,omitempty"`
	// This field will be calcuated at runtime. Default to false
	// e.g. when there is available physical cluster for logical cluster provision, and its Durability==High, it will be set to true
	IsMultizoneEnabled bool           `protobuf:"varint,6,opt,name=is_multizone_enabled,json=isMultizoneEnabled,proto3" json:"is_multizone_enabled,omitempty" db:"is_multizone_enabled,omitempty" url:"is_multizone_enabled,omitempty"`
	Config             *Region_Config `protobuf:"bytes,7,opt,name=config,proto3" json:"config,omitempty" db:"config,omitempty" url:"config,omitempty"`
	// This is a vanity field. This means that it is not persisted to the DB
	// but computed at runtime.
	Schedulability       *Schedulability `protobuf:"bytes,8,opt,name=schedulability,proto3" json:"schedulability,omitempty" db:"schedulability,omitempty" url:"schedulability,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_Region proto.InternalMessageInfo

func (m *Region) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Region) GetCloud() string {
	if m != nil {
		return m.Cloud
	}
	return ""
}

func (m *Region) GetZones() []*AvailabilityZone {
	if m != nil {
		return m.Zones
	}
	return nil
}

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

func (m *Region) GetIsSchedulable() bool {
	if m != nil {
		return m.IsSchedulable
	}
	return false
}

func (m *Region) GetIsMultizoneEnabled() bool {
	if m != nil {
		return m.IsMultizoneEnabled
	}
	return false
}

func (m *Region) GetConfig() *Region_Config {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *Region) GetSchedulability() *Schedulability {
	if m != nil {
		return m.Schedulability
	}
	return nil
}

type Region_Docker struct {
	Repo                 string   `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty" db:"repo,omitempty" url:"repo,omitempty"`
	ImagePrefix          string   `protobuf:"bytes,2,opt,name=image_prefix,json=imagePrefix,proto3" json:"image_prefix,omitempty" db:"image_prefix,omitempty" url:"image_prefix,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Region_Docker proto.InternalMessageInfo

func (m *Region_Docker) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

func (m *Region_Docker) GetImagePrefix() string {
	if m != nil {
		return m.ImagePrefix
	}
	return ""
}

type Region_Config struct {
	Docker               *Region_Docker `protobuf:"bytes,1,opt,name=docker,proto3" json:"docker,omitempty" db:"docker,omitempty" url:"docker,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_Region_Config proto.InternalMessageInfo

func (m *Region_Config) GetDocker() *Region_Docker {
	if m != nil {
		return m.Docker
	}
	return nil
}

type AccountMetadata struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AccountMetadata proto.InternalMessageInfo

func (m *AccountMetadata) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type CloudMetadata struct {
	Id                   string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"`
	Regions              []*Region          `protobuf:"bytes,2,rep,name=regions,proto3" json:"regions,omitempty" db:"regions,omitempty" url:"regions,omitempty"`
	Name                 string             `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"`
	Accounts             []*AccountMetadata `protobuf:"bytes,4,rep,name=accounts,proto3" json:"accounts,omitempty" db:"accounts,omitempty" url:"accounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_CloudMetadata proto.InternalMessageInfo

func (m *CloudMetadata) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *CloudMetadata) GetRegions() []*Region {
	if m != nil {
		return m.Regions
	}
	return nil
}

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

func (m *CloudMetadata) GetAccounts() []*AccountMetadata {
	if m != nil {
		return m.Accounts
	}
	return nil
}

type SchemaRegistryLocation struct {
	Id                    GlobalSchemaRegistryLocation `protobuf:"varint,1,opt,name=id,proto3,enum=ccloud.scheduler.GlobalSchemaRegistryLocation" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"` // Deprecated: Do not use.
	Name                  string                       `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"`                                             // Deprecated: Do not use.
	ClusterId             string                       `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty" db:"cluster_id,omitempty" url:"cluster_id,omitempty"`
	ServiceProvider       string                       `protobuf:"bytes,4,opt,name=service_provider,json=serviceProvider,proto3" json:"service_provider,omitempty" db:"service_provider,omitempty" url:"service_provider,omitempty"`
	Package               []string                     `protobuf:"bytes,5,rep,name=package,proto3" json:"package,omitempty" db:"package,omitempty" url:"package,omitempty"`
	ServiceProviderRegion string                       `protobuf:"bytes,6,opt,name=service_provider_region,json=serviceProviderRegion,proto3" json:"service_provider_region,omitempty" db:"service_provider_region,omitempty" url:"service_provider_region,omitempty"`
	RegionDisplayName     string                       `protobuf:"bytes,7,opt,name=region_display_name,json=regionDisplayName,proto3" json:"region_display_name,omitempty" db:"region_display_name,omitempty" url:"region_display_name,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                     `json:"-"`
	XXX_unrecognized      []byte                       `json:"-"`
	XXX_sizecache         int32                        `json:"-"`
}

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

var xxx_messageInfo_SchemaRegistryLocation proto.InternalMessageInfo

// Deprecated: Do not use.
func (m *SchemaRegistryLocation) GetId() GlobalSchemaRegistryLocation {
	if m != nil {
		return m.Id
	}
	return GlobalSchemaRegistryLocation_NONE
}

// Deprecated: Do not use.
func (m *SchemaRegistryLocation) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SchemaRegistryLocation) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *SchemaRegistryLocation) GetServiceProvider() string {
	if m != nil {
		return m.ServiceProvider
	}
	return ""
}

func (m *SchemaRegistryLocation) GetPackage() []string {
	if m != nil {
		return m.Package
	}
	return nil
}

func (m *SchemaRegistryLocation) GetServiceProviderRegion() string {
	if m != nil {
		return m.ServiceProviderRegion
	}
	return ""
}

func (m *SchemaRegistryLocation) GetRegionDisplayName() string {
	if m != nil {
		return m.RegionDisplayName
	}
	return ""
}

type EnvironmentStatus struct {
	Info                 string   `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty" db:"info,omitempty" url:"info,omitempty"`
	Error                string   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EnvironmentStatus proto.InternalMessageInfo

func (m *EnvironmentStatus) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

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

type GetEnvironmentMetadataReply struct {
	Error                   *Error                    `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	Clouds                  []*CloudMetadata          `protobuf:"bytes,2,rep,name=clouds,proto3" json:"clouds,omitempty" db:"clouds,omitempty" url:"clouds,omitempty"`
	Status                  *EnvironmentStatus        `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty" db:"status,omitempty" url:"status,omitempty"`
	SchemaRegistryLocations []*SchemaRegistryLocation `protobuf:"bytes,4,rep,name=schema_registry_locations,json=schemaRegistryLocations,proto3" json:"schema_registry_locations,omitempty" db:"schema_registry_locations,omitempty" url:"schema_registry_locations,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                  `json:"-"`
	XXX_unrecognized        []byte                    `json:"-"`
	XXX_sizecache           int32                     `json:"-"`
}

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

var xxx_messageInfo_GetEnvironmentMetadataReply proto.InternalMessageInfo

func (m *GetEnvironmentMetadataReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *GetEnvironmentMetadataReply) GetClouds() []*CloudMetadata {
	if m != nil {
		return m.Clouds
	}
	return nil
}

func (m *GetEnvironmentMetadataReply) GetStatus() *EnvironmentStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *GetEnvironmentMetadataReply) GetSchemaRegistryLocations() []*SchemaRegistryLocation {
	if m != nil {
		return m.SchemaRegistryLocations
	}
	return nil
}

type CreateSchemaRegistryClusterRequest struct {
	Config               *SchemaRegistryClusterConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty" db:"config,omitempty" url:"config,omitempty"`
	RequestCarrier       map[string]string            `protobuf:"bytes,2,rep,name=request_carrier,json=requestCarrier,proto3" json:"request_carrier,omitempty" redact:"-" db:"request_carrier,omitempty" url:"request_carrier,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Cluster              *SchemaRegistryCluster       `protobuf:"bytes,4,opt,name=cluster,proto3" json:"cluster,omitempty" db:"cluster,omitempty" url:"cluster,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_CreateSchemaRegistryClusterRequest proto.InternalMessageInfo

func (m *CreateSchemaRegistryClusterRequest) GetConfig() *SchemaRegistryClusterConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *CreateSchemaRegistryClusterRequest) GetRequestCarrier() map[string]string {
	if m != nil {
		return m.RequestCarrier
	}
	return nil
}

func (m *CreateSchemaRegistryClusterRequest) GetCluster() *SchemaRegistryCluster {
	if m != nil {
		return m.Cluster
	}
	return nil
}

type CreateSchemaRegistryClusterReply struct {
	Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	// {"field name": "err msg"}
	ValidationErrors     map[string]string      `protobuf:"bytes,2,rep,name=validation_errors,json=validationErrors,proto3" json:"validation_errors,omitempty" db:"validation_errors,omitempty" url:"validation_errors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Cluster              *SchemaRegistryCluster `protobuf:"bytes,3,opt,name=cluster,proto3" json:"cluster,omitempty" db:"cluster,omitempty" url:"cluster,omitempty"`
	Credentials          *APICredentials        `protobuf:"bytes,4,opt,name=credentials,proto3" json:"credentials,omitempty" db:"credentials,omitempty" url:"credentials,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_CreateSchemaRegistryClusterReply proto.InternalMessageInfo

func (m *CreateSchemaRegistryClusterReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *CreateSchemaRegistryClusterReply) GetValidationErrors() map[string]string {
	if m != nil {
		return m.ValidationErrors
	}
	return nil
}

func (m *CreateSchemaRegistryClusterReply) GetCluster() *SchemaRegistryCluster {
	if m != nil {
		return m.Cluster
	}
	return nil
}

func (m *CreateSchemaRegistryClusterReply) GetCredentials() *APICredentials {
	if m != nil {
		return m.Credentials
	}
	return nil
}

type GetSchemaRegistryClustersReply struct {
	Error                *Error                   `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	Clusters             []*SchemaRegistryCluster `protobuf:"bytes,2,rep,name=clusters,proto3" json:"clusters,omitempty" db:"clusters,omitempty" url:"clusters,omitempty"`
	NextPageToken        string                   `protobuf:"bytes,3,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty" db:"next_page_token,omitempty" url:"next_page_token,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_GetSchemaRegistryClustersReply proto.InternalMessageInfo

func (m *GetSchemaRegistryClustersReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *GetSchemaRegistryClustersReply) GetClusters() []*SchemaRegistryCluster {
	if m != nil {
		return m.Clusters
	}
	return nil
}

func (m *GetSchemaRegistryClustersReply) GetNextPageToken() string {
	if m != nil {
		return m.NextPageToken
	}
	return ""
}

type GetSchemaRegistryClusterReply struct {
	Error                *Error                 `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	Cluster              *SchemaRegistryCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty" db:"cluster,omitempty" url:"cluster,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_GetSchemaRegistryClusterReply proto.InternalMessageInfo

func (m *GetSchemaRegistryClusterReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *GetSchemaRegistryClusterReply) GetCluster() *SchemaRegistryCluster {
	if m != nil {
		return m.Cluster
	}
	return nil
}

type UpdateSchemaRegistryClusterRequest struct {
	Cluster              *SchemaRegistryCluster `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty" db:"cluster,omitempty" url:"cluster,omitempty"`
	RequestCarrier       map[string]string      `protobuf:"bytes,2,rep,name=request_carrier,json=requestCarrier,proto3" json:"request_carrier,omitempty" redact:"-" db:"request_carrier,omitempty" url:"request_carrier,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 *UpdateSchemaRegistryClusterRequest) Reset()         { *m = UpdateSchemaRegistryClusterRequest{} }
func (m *UpdateSchemaRegistryClusterRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSchemaRegistryClusterRequest) ProtoMessage()    {}
func (*UpdateSchemaRegistryClusterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_3d8db78ba60fec18, []int{13}
}
func (m *UpdateSchemaRegistryClusterRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateSchemaRegistryClusterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateSchemaRegistryClusterRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateSchemaRegistryClusterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateSchemaRegistryClusterRequest.Merge(m, src)
}
func (m *UpdateSchemaRegistryClusterRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateSchemaRegistryClusterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateSchemaRegistryClusterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateSchemaRegistryClusterRequest proto.InternalMessageInfo

func (m *UpdateSchemaRegistryClusterRequest) GetCluster() *SchemaRegistryCluster {
	if m != nil {
		return m.Cluster
	}
	return nil
}

func (m *UpdateSchemaRegistryClusterRequest) GetRequestCarrier() map[string]string {
	if m != nil {
		return m.RequestCarrier
	}
	return nil
}

type UpdateSchemaRegistryClusterReply struct {
	Error                *Error                 `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	ValidationErrors     map[string]string      `protobuf:"bytes,2,rep,name=validation_errors,json=validationErrors,proto3" json:"validation_errors,omitempty" db:"validation_errors,omitempty" url:"validation_errors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Cluster              *SchemaRegistryCluster `protobuf:"bytes,3,opt,name=cluster,proto3" json:"cluster,omitempty" db:"cluster,omitempty" url:"cluster,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_UpdateSchemaRegistryClusterReply proto.InternalMessageInfo

func (m *UpdateSchemaRegistryClusterReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *UpdateSchemaRegistryClusterReply) GetValidationErrors() map[string]string {
	if m != nil {
		return m.ValidationErrors
	}
	return nil
}

func (m *UpdateSchemaRegistryClusterReply) GetCluster() *SchemaRegistryCluster {
	if m != nil {
		return m.Cluster
	}
	return nil
}

type DeleteSchemaValidationResourcesRequest struct {
	LogicalClusterId     string   `protobuf:"bytes,1,opt,name=logical_cluster_id,json=logicalClusterId,proto3" json:"logical_cluster_id,omitempty" db:"logical_cluster_id,omitempty" url:"logical_cluster_id,omitempty"`
	OrganizationId       int32    `protobuf:"varint,2,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty" db:"organization_id,omitempty" url:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteSchemaValidationResourcesRequest proto.InternalMessageInfo

func (m *DeleteSchemaValidationResourcesRequest) GetLogicalClusterId() string {
	if m != nil {
		return m.LogicalClusterId
	}
	return ""
}

func (m *DeleteSchemaValidationResourcesRequest) GetOrganizationId() int32 {
	if m != nil {
		return m.OrganizationId
	}
	return 0
}

type DeleteSchemaValidationResourcesReply struct {
	Error                *Error   `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteSchemaValidationResourcesReply proto.InternalMessageInfo

func (m *DeleteSchemaValidationResourcesReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type DeleteSchemaRegistryClusterReply struct {
	Error                *Error   `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty" db:"error,omitempty" url:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteSchemaRegistryClusterReply proto.InternalMessageInfo

func (m *DeleteSchemaRegistryClusterReply) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type SchemaRegistryClusterConfig struct {
	Name                  string                       `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"` // Deprecated: Do not use.
	KafkaClusterId        string                       `protobuf:"bytes,1,opt,name=kafka_cluster_id,json=kafkaClusterId,proto3" json:"kafka_cluster_id,omitempty" db:"kafka_cluster_id,omitempty" url:"kafka_cluster_id,omitempty"`
	Servers               int32                        `protobuf:"varint,2,opt,name=servers,proto3" json:"servers,omitempty" db:"servers,omitempty" url:"servers,omitempty"`
	AccountId             string                       `protobuf:"bytes,3,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty" db:"account_id,omitempty" url:"account_id,omitempty"`
	Location              GlobalSchemaRegistryLocation `protobuf:"varint,5,opt,name=location,proto3,enum=ccloud.scheduler.GlobalSchemaRegistryLocation" json:"location,omitempty" db:"location,omitempty" url:"location,omitempty"` // Deprecated: Do not use.
	ServiceProvider       string                       `protobuf:"bytes,6,opt,name=service_provider,json=serviceProvider,proto3" json:"service_provider,omitempty" db:"service_provider,omitempty" url:"service_provider,omitempty"`
	PhysicalClusterId     string                       `protobuf:"bytes,7,opt,name=physical_cluster_id,json=physicalClusterId,proto3" json:"physical_cluster_id,omitempty" db:"physical_cluster_id,omitempty" url:"physical_cluster_id,omitempty"`
	Package               string                       `protobuf:"bytes,8,opt,name=package,proto3" json:"package,omitempty" db:"package,omitempty" url:"package,omitempty"`
	ServiceProviderRegion string                       `protobuf:"bytes,9,opt,name=service_provider_region,json=serviceProviderRegion,proto3" json:"service_provider_region,omitempty" db:"service_provider_region,omitempty" url:"service_provider_region,omitempty"`
	Region                *StreamGovernanceRegion      `protobuf:"bytes,10,opt,name=region,proto3" json:"region,omitempty" db:"region,omitempty" url:"region,omitempty"`
	Dedicated             bool                         `protobuf:"varint,11,opt,name=dedicated,proto3" json:"dedicated,omitempty" db:"dedicated,omitempty" url:"dedicated,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                     `json:"-"`
	XXX_unrecognized      []byte                       `json:"-"`
	XXX_sizecache         int32                        `json:"-"`
}

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

var xxx_messageInfo_SchemaRegistryClusterConfig proto.InternalMessageInfo

// Deprecated: Do not use.
func (m *SchemaRegistryClusterConfig) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetKafkaClusterId() string {
	if m != nil {
		return m.KafkaClusterId
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetServers() int32 {
	if m != nil {
		return m.Servers
	}
	return 0
}

func (m *SchemaRegistryClusterConfig) GetAccountId() string {
	if m != nil {
		return m.AccountId
	}
	return ""
}

// Deprecated: Do not use.
func (m *SchemaRegistryClusterConfig) GetLocation() GlobalSchemaRegistryLocation {
	if m != nil {
		return m.Location
	}
	return GlobalSchemaRegistryLocation_NONE
}

func (m *SchemaRegistryClusterConfig) GetServiceProvider() string {
	if m != nil {
		return m.ServiceProvider
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetPhysicalClusterId() string {
	if m != nil {
		return m.PhysicalClusterId
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetPackage() string {
	if m != nil {
		return m.Package
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetServiceProviderRegion() string {
	if m != nil {
		return m.ServiceProviderRegion
	}
	return ""
}

func (m *SchemaRegistryClusterConfig) GetRegion() *StreamGovernanceRegion {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *SchemaRegistryClusterConfig) GetDedicated() bool {
	if m != nil {
		return m.Dedicated
	}
	return false
}

type SchemaRegistryCluster struct {
	Id                string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" db:"id,omitempty" url:"id,omitempty"`
	Name              string           `protobuf:"bytes,10,opt,name=name,proto3" json:"name,omitempty" db:"name,omitempty" url:"name,omitempty"`
	KafkaClusterId    string           `protobuf:"bytes,2,opt,name=kafka_cluster_id,json=kafkaClusterId,proto3" json:"kafka_cluster_id,omitempty" db:"kafka_cluster_id,omitempty" url:"kafka_cluster_id,omitempty"`
	Endpoint          string           `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty" db:"endpoint,omitempty" url:"endpoint,omitempty"`
	Created           *types.Timestamp `protobuf:"bytes,4,opt,name=created,proto3" json:"created,omitempty" db:"created,omitempty" url:"created,omitempty"`
	Modified          *types.Timestamp `protobuf:"bytes,5,opt,name=modified,proto3" json:"modified,omitempty" db:"modified,omitempty" url:"modified,omitempty"`
	Status            ClusterStatus    `protobuf:"varint,6,opt,name=status,proto3,enum=ccloud.scheduler.ClusterStatus" json:"status,omitempty" db:"status,omitempty" url:"status,omitempty"`
	PhysicalClusterId string           `protobuf:"bytes,7,opt,name=physical_cluster_id,json=physicalClusterId,proto3" json:"physical_cluster_id,omitempty" db:"physical_cluster_id,omitempty" url:"physical_cluster_id,omitempty"`
	AccountId         string           `protobuf:"bytes,8,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty" url:"account_id" db:"account_id,omitempty"`
	OrganizationId    int32            `protobuf:"varint,9,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty" db:"organization_id,omitempty" url:"organization_id,omitempty"`
	// maximum number of schemas allowed for this logical cluster
	MaxSchemas            int32                   `protobuf:"varint,11,opt,name=max_schemas,json=maxSchemas,proto3" json:"max_schemas,omitempty" db:"max_schemas,omitempty" url:"max_schemas,omitempty"`
	OrgResourceId         string                  `protobuf:"bytes,12,opt,name=org_resource_id,json=orgResourceId,proto3" json:"org_resource_id,omitempty" db:"org_resource_id,omitempty" url:"org_resource_id,omitempty"`
	Package               string                  `protobuf:"bytes,13,opt,name=package,proto3" json:"package,omitempty" db:"package,omitempty" url:"package,omitempty"`
	ServiceProvider       string                  `protobuf:"bytes,17,opt,name=service_provider,json=serviceProvider,proto3" json:"service_provider,omitempty" db:"service_provider,omitempty" url:"service_provider,omitempty"`
	ServiceProviderRegion string                  `protobuf:"bytes,18,opt,name=service_provider_region,json=serviceProviderRegion,proto3" json:"service_provider_region,omitempty" db:"service_provider_region,omitempty" url:"service_provider_region,omitempty"`
	Region                *StreamGovernanceRegion `protobuf:"bytes,19,opt,name=region,proto3" json:"region,omitempty" db:"region,omitempty" url:"region,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}                `json:"-"`
	XXX_unrecognized      []byte                  `json:"-"`
	XXX_sizecache         int32                   `json:"-"`
}

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

var xxx_messageInfo_SchemaRegistryCluster proto.InternalMessageInfo

func (m *SchemaRegistryCluster) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *SchemaRegistryCluster) GetKafkaClusterId() string {
	if m != nil {
		return m.KafkaClusterId
	}
	return ""
}

func (m *SchemaRegistryCluster) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

func (m *SchemaRegistryCluster) GetCreated() *types.Timestamp {
	if m != nil {
		return m.Created
	}
	return nil
}

func (m *SchemaRegistryCluster) GetModified() *types.Timestamp {
	if m != nil {
		return m.Modified
	}
	return nil
}

func (m *SchemaRegistryCluster) GetStatus() ClusterStatus {
	if m != nil {
		return m.Status
	}
	return ClusterStatus_PROVISIONING
}

func (m *SchemaRegistryCluster) GetPhysicalClusterId() string {
	if m != nil {
		return m.PhysicalClusterId
	}
	return ""
}

func (m *SchemaRegistryCluster) GetAccountId() string {
	if m != nil {
		return m.AccountId
	}
	return ""
}

func (m *SchemaRegistryCluster) GetOrganizationId() int32 {
	if m != nil {
		return m.OrganizationId
	}
	return 0
}

func (m *SchemaRegistryCluster) GetMaxSchemas() int32 {
	if m != nil {
		return m.MaxSchemas
	}
	return 0
}

func (m *SchemaRegistryCluster) GetOrgResourceId() string {
	if m != nil {
		return m.OrgResourceId
	}
	return ""
}

func (m *SchemaRegistryCluster) GetPackage() string {
	if m != nil {
		return m.Package
	}
	return ""
}

func (m *SchemaRegistryCluster) GetServiceProvider() string {
	if m != nil {
		return m.ServiceProvider
	}
	return ""
}

func (m *SchemaRegistryCluster) GetServiceProviderRegion() string {
	if m != nil {
		return m.ServiceProviderRegion
	}
	return ""
}

func (m *SchemaRegistryCluster) GetRegion() *StreamGovernanceRegion {
	if m != nil {
		return m.Region
	}
	return nil
}

func init() {
	proto.RegisterEnum("ccloud.scheduler.NetworkType", NetworkType_name, NetworkType_value)
	proto.RegisterEnum("ccloud.scheduler.GlobalSchemaRegistryLocation", GlobalSchemaRegistryLocation_name, GlobalSchemaRegistryLocation_value)
	proto.RegisterEnum("ccloud.scheduler.ClusterStatus", ClusterStatus_name, ClusterStatus_value)
	proto.RegisterType((*APICredentials)(nil), "ccloud.scheduler.APICredentials")
	proto.RegisterType((*Schedulability)(nil), "ccloud.scheduler.Schedulability")
	proto.RegisterType((*Schedulability_Tenancy)(nil), "ccloud.scheduler.Schedulability.Tenancy")
	proto.RegisterType((*Schedulability_Tenancy_Durability)(nil), "ccloud.scheduler.Schedulability.Tenancy.Durability")
	proto.RegisterType((*AvailabilityZone)(nil), "ccloud.scheduler.AvailabilityZone")
	proto.RegisterType((*Region)(nil), "ccloud.scheduler.Region")
	proto.RegisterType((*Region_Docker)(nil), "ccloud.scheduler.Region.Docker")
	proto.RegisterType((*Region_Config)(nil), "ccloud.scheduler.Region.Config")
	proto.RegisterType((*AccountMetadata)(nil), "ccloud.scheduler.AccountMetadata")
	proto.RegisterType((*CloudMetadata)(nil), "ccloud.scheduler.CloudMetadata")
	proto.RegisterType((*SchemaRegistryLocation)(nil), "ccloud.scheduler.SchemaRegistryLocation")
	proto.RegisterType((*EnvironmentStatus)(nil), "ccloud.scheduler.EnvironmentStatus")
	proto.RegisterType((*GetEnvironmentMetadataReply)(nil), "ccloud.scheduler.GetEnvironmentMetadataReply")
	proto.RegisterType((*CreateSchemaRegistryClusterRequest)(nil), "ccloud.scheduler.CreateSchemaRegistryClusterRequest")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.scheduler.CreateSchemaRegistryClusterRequest.RequestCarrierEntry")
	proto.RegisterType((*CreateSchemaRegistryClusterReply)(nil), "ccloud.scheduler.CreateSchemaRegistryClusterReply")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.scheduler.CreateSchemaRegistryClusterReply.ValidationErrorsEntry")
	proto.RegisterType((*GetSchemaRegistryClustersReply)(nil), "ccloud.scheduler.GetSchemaRegistryClustersReply")
	proto.RegisterType((*GetSchemaRegistryClusterReply)(nil), "ccloud.scheduler.GetSchemaRegistryClusterReply")
	proto.RegisterType((*UpdateSchemaRegistryClusterRequest)(nil), "ccloud.scheduler.UpdateSchemaRegistryClusterRequest")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.scheduler.UpdateSchemaRegistryClusterRequest.RequestCarrierEntry")
	proto.RegisterType((*UpdateSchemaRegistryClusterReply)(nil), "ccloud.scheduler.UpdateSchemaRegistryClusterReply")
	proto.RegisterMapType((map[string]string)(nil), "ccloud.scheduler.UpdateSchemaRegistryClusterReply.ValidationErrorsEntry")
	proto.RegisterType((*DeleteSchemaValidationResourcesRequest)(nil), "ccloud.scheduler.DeleteSchemaValidationResourcesRequest")
	proto.RegisterType((*DeleteSchemaValidationResourcesReply)(nil), "ccloud.scheduler.DeleteSchemaValidationResourcesReply")
	proto.RegisterType((*DeleteSchemaRegistryClusterReply)(nil), "ccloud.scheduler.DeleteSchemaRegistryClusterReply")
	proto.RegisterType((*SchemaRegistryClusterConfig)(nil), "ccloud.scheduler.SchemaRegistryClusterConfig")
	proto.RegisterType((*SchemaRegistryCluster)(nil), "ccloud.scheduler.SchemaRegistryCluster")
}

func init() { proto.RegisterFile("scheduler/scheduler.proto", fileDescriptor_3d8db78ba60fec18) }

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

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

func (m *APICredentials) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Secret) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Secret)))
		i += copy(dAtA[i:], m.Secret)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Schedulability) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SharedNetwork != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.SharedNetwork.Size()))
		n1, err := m.SharedNetwork.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.DedicatedNetwork != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.DedicatedNetwork.Size()))
		n2, err := m.DedicatedNetwork.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Schedulability_Tenancy) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SharedCluster != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.SharedCluster.Size()))
		n3, err := m.SharedCluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.DedicatedCluster != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.DedicatedCluster.Size()))
		n4, err := m.DedicatedCluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Schedulability_Tenancy_Durability) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Low) > 0 {
		dAtA6 := make([]byte, len(m.Low)*10)
		var j5 int
		for _, num := range m.Low {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	if len(m.High) > 0 {
		dAtA8 := make([]byte, len(m.High)*10)
		var j7 int
		for _, num := range m.High {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(j7))
		i += copy(dAtA[i:], dAtA8[:j7])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *AvailabilityZone) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.ZoneId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ZoneId)))
		i += copy(dAtA[i:], m.ZoneId)
	}
	if len(m.Id) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.RegionId) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.RegionId)))
		i += copy(dAtA[i:], m.RegionId)
	}
	if m.SniEnabled != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.SniEnabled.Size()))
		n9, err := m.SniEnabled.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.Schedulable != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Schedulable.Size()))
		n10, err := m.Schedulable.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.Created != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Created)))
		n11, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Created, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.Modified != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Modified)))
		n12, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Modified, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.Deactivated != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Deactivated)))
		n13, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Deactivated, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if len(m.Realm) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Realm)))
		i += copy(dAtA[i:], m.Realm)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Region) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Cloud) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Cloud)))
		i += copy(dAtA[i:], m.Cloud)
	}
	if len(m.Zones) > 0 {
		for _, msg := range m.Zones {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.IsSchedulable {
		dAtA[i] = 0x28
		i++
		if m.IsSchedulable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.IsMultizoneEnabled {
		dAtA[i] = 0x30
		i++
		if m.IsMultizoneEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Config != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Config.Size()))
		n14, err := m.Config.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.Schedulability != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Schedulability.Size()))
		n15, err := m.Schedulability.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Region_Docker) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Repo) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Repo)))
		i += copy(dAtA[i:], m.Repo)
	}
	if len(m.ImagePrefix) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ImagePrefix)))
		i += copy(dAtA[i:], m.ImagePrefix)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Region_Config) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Docker != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Docker.Size()))
		n16, err := m.Docker.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *AccountMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *CloudMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Regions) > 0 {
		for _, msg := range m.Regions {
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Accounts) > 0 {
		for _, msg := range m.Accounts {
			dAtA[i] = 0x22
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SchemaRegistryLocation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Id))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.ClusterId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ClusterId)))
		i += copy(dAtA[i:], m.ClusterId)
	}
	if len(m.ServiceProvider) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProvider)))
		i += copy(dAtA[i:], m.ServiceProvider)
	}
	if len(m.Package) > 0 {
		for _, s := range m.Package {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ServiceProviderRegion) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProviderRegion)))
		i += copy(dAtA[i:], m.ServiceProviderRegion)
	}
	if len(m.RegionDisplayName) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.RegionDisplayName)))
		i += copy(dAtA[i:], m.RegionDisplayName)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *EnvironmentStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Info) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Info)))
		i += copy(dAtA[i:], m.Info)
	}
	if len(m.Error) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Error)))
		i += copy(dAtA[i:], m.Error)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *GetEnvironmentMetadataReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n17, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if len(m.Clouds) > 0 {
		for _, msg := range m.Clouds {
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Status != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Status.Size()))
		n18, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if len(m.SchemaRegistryLocations) > 0 {
		for _, msg := range m.SchemaRegistryLocations {
			dAtA[i] = 0x22
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *CreateSchemaRegistryClusterRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Config != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Config.Size()))
		n19, err := m.Config.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if len(m.RequestCarrier) > 0 {
		for k, _ := range m.RequestCarrier {
			dAtA[i] = 0x12
			i++
			v := m.RequestCarrier[k]
			mapSize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			i = encodeVarintScheduler(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.Cluster != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Cluster.Size()))
		n20, err := m.Cluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *CreateSchemaRegistryClusterReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n21, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if len(m.ValidationErrors) > 0 {
		for k, _ := range m.ValidationErrors {
			dAtA[i] = 0x12
			i++
			v := m.ValidationErrors[k]
			mapSize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			i = encodeVarintScheduler(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.Cluster != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Cluster.Size()))
		n22, err := m.Cluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	if m.Credentials != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Credentials.Size()))
		n23, err := m.Credentials.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *GetSchemaRegistryClustersReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n24, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if len(m.Clusters) > 0 {
		for _, msg := range m.Clusters {
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NextPageToken) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.NextPageToken)))
		i += copy(dAtA[i:], m.NextPageToken)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *GetSchemaRegistryClusterReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n25, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	if m.Cluster != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Cluster.Size()))
		n26, err := m.Cluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UpdateSchemaRegistryClusterRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Cluster != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Cluster.Size()))
		n27, err := m.Cluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	if len(m.RequestCarrier) > 0 {
		for k, _ := range m.RequestCarrier {
			dAtA[i] = 0x12
			i++
			v := m.RequestCarrier[k]
			mapSize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			i = encodeVarintScheduler(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UpdateSchemaRegistryClusterReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n28, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n28
	}
	if len(m.ValidationErrors) > 0 {
		for k, _ := range m.ValidationErrors {
			dAtA[i] = 0x12
			i++
			v := m.ValidationErrors[k]
			mapSize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			i = encodeVarintScheduler(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintScheduler(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.Cluster != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Cluster.Size()))
		n29, err := m.Cluster.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *DeleteSchemaValidationResourcesRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.LogicalClusterId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.LogicalClusterId)))
		i += copy(dAtA[i:], m.LogicalClusterId)
	}
	if m.OrganizationId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.OrganizationId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *DeleteSchemaValidationResourcesReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n30, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *DeleteSchemaRegistryClusterReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Error.Size()))
		n31, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n31
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SchemaRegistryClusterConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.KafkaClusterId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.KafkaClusterId)))
		i += copy(dAtA[i:], m.KafkaClusterId)
	}
	if m.Servers != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Servers))
	}
	if len(m.AccountId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.AccountId)))
		i += copy(dAtA[i:], m.AccountId)
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Location != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Location))
	}
	if len(m.ServiceProvider) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProvider)))
		i += copy(dAtA[i:], m.ServiceProvider)
	}
	if len(m.PhysicalClusterId) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.PhysicalClusterId)))
		i += copy(dAtA[i:], m.PhysicalClusterId)
	}
	if len(m.Package) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Package)))
		i += copy(dAtA[i:], m.Package)
	}
	if len(m.ServiceProviderRegion) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProviderRegion)))
		i += copy(dAtA[i:], m.ServiceProviderRegion)
	}
	if m.Region != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Region.Size()))
		n32, err := m.Region.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	if m.Dedicated {
		dAtA[i] = 0x58
		i++
		if m.Dedicated {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SchemaRegistryCluster) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.KafkaClusterId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.KafkaClusterId)))
		i += copy(dAtA[i:], m.KafkaClusterId)
	}
	if len(m.Endpoint) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Endpoint)))
		i += copy(dAtA[i:], m.Endpoint)
	}
	if m.Created != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Created.Size()))
		n33, err := m.Created.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	if m.Modified != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Modified.Size()))
		n34, err := m.Modified.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n34
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Status))
	}
	if len(m.PhysicalClusterId) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.PhysicalClusterId)))
		i += copy(dAtA[i:], m.PhysicalClusterId)
	}
	if len(m.AccountId) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.AccountId)))
		i += copy(dAtA[i:], m.AccountId)
	}
	if m.OrganizationId != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.OrganizationId))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.MaxSchemas != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.MaxSchemas))
	}
	if len(m.OrgResourceId) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.OrgResourceId)))
		i += copy(dAtA[i:], m.OrgResourceId)
	}
	if len(m.Package) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.Package)))
		i += copy(dAtA[i:], m.Package)
	}
	if len(m.ServiceProvider) > 0 {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProvider)))
		i += copy(dAtA[i:], m.ServiceProvider)
	}
	if len(m.ServiceProviderRegion) > 0 {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(len(m.ServiceProviderRegion)))
		i += copy(dAtA[i:], m.ServiceProviderRegion)
	}
	if m.Region != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScheduler(dAtA, i, uint64(m.Region.Size()))
		n35, err := m.Region.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n35
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintScheduler(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *APICredentials) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Secret)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Schedulability) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SharedNetwork != nil {
		l = m.SharedNetwork.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.DedicatedNetwork != nil {
		l = m.DedicatedNetwork.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Schedulability_Tenancy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SharedCluster != nil {
		l = m.SharedCluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.DedicatedCluster != nil {
		l = m.DedicatedCluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *AvailabilityZone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ZoneId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.RegionId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.SniEnabled != nil {
		l = m.SniEnabled.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Schedulable != nil {
		l = m.Schedulable.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Created != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Created)
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Modified != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Modified)
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Deactivated != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Deactivated)
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Realm)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Region) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Cloud)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Zones) > 0 {
		for _, e := range m.Zones {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.IsSchedulable {
		n += 2
	}
	if m.IsMultizoneEnabled {
		n += 2
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Schedulability != nil {
		l = m.Schedulability.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Region_Docker) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Repo)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ImagePrefix)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Region_Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Docker != nil {
		l = m.Docker.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *CloudMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Regions) > 0 {
		for _, e := range m.Regions {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Accounts) > 0 {
		for _, e := range m.Accounts {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SchemaRegistryLocation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovScheduler(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ServiceProvider)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Package) > 0 {
		for _, s := range m.Package {
			l = len(s)
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	l = len(m.ServiceProviderRegion)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.RegionDisplayName)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EnvironmentStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetEnvironmentMetadataReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Clouds) > 0 {
		for _, e := range m.Clouds {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.SchemaRegistryLocations) > 0 {
		for _, e := range m.SchemaRegistryLocations {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateSchemaRegistryClusterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.RequestCarrier) > 0 {
		for k, v := range m.RequestCarrier {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			n += mapEntrySize + 1 + sovScheduler(uint64(mapEntrySize))
		}
	}
	if m.Cluster != nil {
		l = m.Cluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateSchemaRegistryClusterReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.ValidationErrors) > 0 {
		for k, v := range m.ValidationErrors {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			n += mapEntrySize + 1 + sovScheduler(uint64(mapEntrySize))
		}
	}
	if m.Cluster != nil {
		l = m.Cluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Credentials != nil {
		l = m.Credentials.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetSchemaRegistryClustersReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.Clusters) > 0 {
		for _, e := range m.Clusters {
			l = e.Size()
			n += 1 + l + sovScheduler(uint64(l))
		}
	}
	l = len(m.NextPageToken)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetSchemaRegistryClusterReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Cluster != nil {
		l = m.Cluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateSchemaRegistryClusterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cluster != nil {
		l = m.Cluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.RequestCarrier) > 0 {
		for k, v := range m.RequestCarrier {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			n += mapEntrySize + 1 + sovScheduler(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateSchemaRegistryClusterReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if len(m.ValidationErrors) > 0 {
		for k, v := range m.ValidationErrors {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovScheduler(uint64(len(k))) + 1 + len(v) + sovScheduler(uint64(len(v)))
			n += mapEntrySize + 1 + sovScheduler(uint64(mapEntrySize))
		}
	}
	if m.Cluster != nil {
		l = m.Cluster.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteSchemaValidationResourcesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LogicalClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.OrganizationId != 0 {
		n += 1 + sovScheduler(uint64(m.OrganizationId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteSchemaValidationResourcesReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteSchemaRegistryClusterReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SchemaRegistryClusterConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.KafkaClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Servers != 0 {
		n += 1 + sovScheduler(uint64(m.Servers))
	}
	l = len(m.AccountId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Location != 0 {
		n += 1 + sovScheduler(uint64(m.Location))
	}
	l = len(m.ServiceProvider)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.PhysicalClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Package)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ServiceProviderRegion)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Region != nil {
		l = m.Region.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Dedicated {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SchemaRegistryCluster) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.KafkaClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Endpoint)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Created != nil {
		l = m.Created.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Modified != nil {
		l = m.Modified.Size()
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovScheduler(uint64(m.Status))
	}
	l = len(m.PhysicalClusterId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.AccountId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.OrganizationId != 0 {
		n += 1 + sovScheduler(uint64(m.OrganizationId))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	if m.MaxSchemas != 0 {
		n += 1 + sovScheduler(uint64(m.MaxSchemas))
	}
	l = len(m.OrgResourceId)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.Package)
	if l > 0 {
		n += 1 + l + sovScheduler(uint64(l))
	}
	l = len(m.ServiceProvider)
	if l > 0 {
		n += 2 + l + sovScheduler(uint64(l))
	}
	l = len(m.ServiceProviderRegion)
	if l > 0 {
		n += 2 + l + sovScheduler(uint64(l))
	}
	if m.Region != nil {
		l = m.Region.Size()
		n += 2 + l + sovScheduler(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovScheduler(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozScheduler(x uint64) (n int) {
	return sovScheduler(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *APICredentials) 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 ErrIntOverflowScheduler
			}
			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: APICredentials: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: APICredentials: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Secret = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Schedulability) 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 ErrIntOverflowScheduler
			}
			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: Schedulability: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Schedulability: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedNetwork", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SharedNetwork == nil {
				m.SharedNetwork = &Schedulability_Tenancy{}
			}
			if err := m.SharedNetwork.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DedicatedNetwork", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DedicatedNetwork == nil {
				m.DedicatedNetwork = &Schedulability_Tenancy{}
			}
			if err := m.DedicatedNetwork.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Schedulability_Tenancy) 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 ErrIntOverflowScheduler
			}
			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: Tenancy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tenancy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedCluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SharedCluster == nil {
				m.SharedCluster = &Schedulability_Tenancy_Durability{}
			}
			if err := m.SharedCluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DedicatedCluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DedicatedCluster == nil {
				m.DedicatedCluster = &Schedulability_Tenancy_Durability{}
			}
			if err := m.DedicatedCluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Schedulability_Tenancy_Durability) 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 ErrIntOverflowScheduler
			}
			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: Durability: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Durability: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v NetworkType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowScheduler
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= NetworkType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Low = append(m.Low, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowScheduler
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthScheduler
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthScheduler
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Low) == 0 {
					m.Low = make([]NetworkType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v NetworkType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowScheduler
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= NetworkType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Low = append(m.Low, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Low", wireType)
			}
		case 2:
			if wireType == 0 {
				var v NetworkType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowScheduler
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= NetworkType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.High = append(m.High, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowScheduler
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthScheduler
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthScheduler
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.High) == 0 {
					m.High = make([]NetworkType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v NetworkType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowScheduler
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= NetworkType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.High = append(m.High, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field High", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *AvailabilityZone) 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 ErrIntOverflowScheduler
			}
			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: AvailabilityZone: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AvailabilityZone: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			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 ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZoneId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RegionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SniEnabled", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SniEnabled == nil {
				m.SniEnabled = &types.BoolValue{}
			}
			if err := m.SniEnabled.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schedulable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Schedulable == nil {
				m.Schedulable = &types.BoolValue{}
			}
			if err := m.Schedulable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Created == nil {
				m.Created = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Created, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Modified", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Modified == nil {
				m.Modified = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Modified, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deactivated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Deactivated == nil {
				m.Deactivated = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Deactivated, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Realm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Realm = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Region) 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 ErrIntOverflowScheduler
			}
			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: Region: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Region: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cloud", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cloud = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zones", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Zones = append(m.Zones, &AvailabilityZone{})
			if err := m.Zones[len(m.Zones)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSchedulable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSchedulable = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsMultizoneEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsMultizoneEnabled = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &Region_Config{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schedulability", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Schedulability == nil {
				m.Schedulability = &Schedulability{}
			}
			if err := m.Schedulability.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Region_Docker) 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 ErrIntOverflowScheduler
			}
			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: Docker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Docker: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Repo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImagePrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImagePrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *Region_Config) 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 ErrIntOverflowScheduler
			}
			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: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Docker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Docker == nil {
				m.Docker = &Region_Docker{}
			}
			if err := m.Docker.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *AccountMetadata) 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 ErrIntOverflowScheduler
			}
			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: AccountMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *CloudMetadata) 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 ErrIntOverflowScheduler
			}
			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: CloudMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Regions = append(m.Regions, &Region{})
			if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Accounts = append(m.Accounts, &AccountMetadata{})
			if err := m.Accounts[len(m.Accounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *SchemaRegistryLocation) 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 ErrIntOverflowScheduler
			}
			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: SchemaRegistryLocation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaRegistryLocation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= GlobalSchemaRegistryLocation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProvider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProvider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Package", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Package = append(m.Package, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProviderRegion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProviderRegion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionDisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RegionDisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *EnvironmentStatus) 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 ErrIntOverflowScheduler
			}
			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: EnvironmentStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnvironmentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *GetEnvironmentMetadataReply) 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 ErrIntOverflowScheduler
			}
			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: GetEnvironmentMetadataReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetEnvironmentMetadataReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Clouds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Clouds = append(m.Clouds, &CloudMetadata{})
			if err := m.Clouds[len(m.Clouds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &EnvironmentStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaRegistryLocations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaRegistryLocations = append(m.SchemaRegistryLocations, &SchemaRegistryLocation{})
			if err := m.SchemaRegistryLocations[len(m.SchemaRegistryLocations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *CreateSchemaRegistryClusterRequest) 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 ErrIntOverflowScheduler
			}
			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: CreateSchemaRegistryClusterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateSchemaRegistryClusterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &SchemaRegistryClusterConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestCarrier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestCarrier == nil {
				m.RequestCarrier = 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 ErrIntOverflowScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthScheduler
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipScheduler(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthScheduler
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequestCarrier[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cluster == nil {
				m.Cluster = &SchemaRegistryCluster{}
			}
			if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *CreateSchemaRegistryClusterReply) 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 ErrIntOverflowScheduler
			}
			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: CreateSchemaRegistryClusterReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateSchemaRegistryClusterReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidationErrors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidationErrors == nil {
				m.ValidationErrors = 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 ErrIntOverflowScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthScheduler
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipScheduler(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthScheduler
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ValidationErrors[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cluster == nil {
				m.Cluster = &SchemaRegistryCluster{}
			}
			if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credentials", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Credentials == nil {
				m.Credentials = &APICredentials{}
			}
			if err := m.Credentials.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *GetSchemaRegistryClustersReply) 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 ErrIntOverflowScheduler
			}
			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: GetSchemaRegistryClustersReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetSchemaRegistryClustersReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Clusters = append(m.Clusters, &SchemaRegistryCluster{})
			if err := m.Clusters[len(m.Clusters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextPageToken", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextPageToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *GetSchemaRegistryClusterReply) 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 ErrIntOverflowScheduler
			}
			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: GetSchemaRegistryClusterReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetSchemaRegistryClusterReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cluster == nil {
				m.Cluster = &SchemaRegistryCluster{}
			}
			if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *UpdateSchemaRegistryClusterRequest) 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 ErrIntOverflowScheduler
			}
			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: UpdateSchemaRegistryClusterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateSchemaRegistryClusterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cluster == nil {
				m.Cluster = &SchemaRegistryCluster{}
			}
			if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestCarrier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestCarrier == nil {
				m.RequestCarrier = 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 ErrIntOverflowScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthScheduler
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipScheduler(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthScheduler
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequestCarrier[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *UpdateSchemaRegistryClusterReply) 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 ErrIntOverflowScheduler
			}
			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: UpdateSchemaRegistryClusterReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateSchemaRegistryClusterReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidationErrors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidationErrors == nil {
				m.ValidationErrors = 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 ErrIntOverflowScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthScheduler
					}
					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 ErrIntOverflowScheduler
						}
						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 ErrInvalidLengthScheduler
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthScheduler
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipScheduler(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthScheduler
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ValidationErrors[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cluster == nil {
				m.Cluster = &SchemaRegistryCluster{}
			}
			if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *DeleteSchemaValidationResourcesRequest) 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 ErrIntOverflowScheduler
			}
			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: DeleteSchemaValidationResourcesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteSchemaValidationResourcesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicalClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogicalClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			m.OrganizationId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrganizationId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *DeleteSchemaValidationResourcesReply) 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 ErrIntOverflowScheduler
			}
			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: DeleteSchemaValidationResourcesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteSchemaValidationResourcesReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *DeleteSchemaRegistryClusterReply) 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 ErrIntOverflowScheduler
			}
			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: DeleteSchemaRegistryClusterReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteSchemaRegistryClusterReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *SchemaRegistryClusterConfig) 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 ErrIntOverflowScheduler
			}
			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: SchemaRegistryClusterConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaRegistryClusterConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KafkaClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KafkaClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Servers", wireType)
			}
			m.Servers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Servers |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			m.Location = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Location |= GlobalSchemaRegistryLocation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProvider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProvider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PhysicalClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PhysicalClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Package", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Package = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProviderRegion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProviderRegion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Region == nil {
				m.Region = &StreamGovernanceRegion{}
			}
			if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dedicated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Dedicated = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 *SchemaRegistryCluster) 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 ErrIntOverflowScheduler
			}
			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: SchemaRegistryCluster: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaRegistryCluster: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KafkaClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KafkaClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Endpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Created == nil {
				m.Created = &types.Timestamp{}
			}
			if err := m.Created.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Modified", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Modified == nil {
				m.Modified = &types.Timestamp{}
			}
			if err := m.Modified.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ClusterStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PhysicalClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PhysicalClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationId", wireType)
			}
			m.OrganizationId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrganizationId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			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 ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSchemas", wireType)
			}
			m.MaxSchemas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxSchemas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgResourceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrgResourceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Package", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Package = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProvider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProvider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceProviderRegion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				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 ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceProviderRegion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScheduler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthScheduler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Region == nil {
				m.Region = &StreamGovernanceRegion{}
			}
			if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScheduler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScheduler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthScheduler
			}
			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 skipScheduler(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowScheduler
			}
			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, ErrIntOverflowScheduler
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowScheduler
				}
				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, ErrInvalidLengthScheduler
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthScheduler
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowScheduler
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipScheduler(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthScheduler
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthScheduler = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowScheduler   = fmt.Errorf("proto: integer overflow")
)