/*
Copyright (c) 2021 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/gardener/gardener/pkg/apis/core/v1alpha1/generated.proto

package v1alpha1

import (
	encoding_binary "encoding/binary"
	fmt "fmt"

	v1beta1 "github.com/gardener/gardener/pkg/apis/core/v1beta1"

	io "io"

	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	k8s_io_api_core_v1 "k8s.io/api/core/v1"
	v1 "k8s.io/api/core/v1"
	v13 "k8s.io/api/rbac/v1"
	resource "k8s.io/apimachinery/pkg/api/resource"
	v11 "k8s.io/apimachinery/pkg/apis/meta/v1"
	runtime "k8s.io/apimachinery/pkg/runtime"

	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"

	k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
	intstr "k8s.io/apimachinery/pkg/util/intstr"
)

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

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

func (m *Addon) Reset()      { *m = Addon{} }
func (*Addon) ProtoMessage() {}
func (*Addon) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{0}
}
func (m *Addon) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Addon) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Addon) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Addon.Merge(m, src)
}
func (m *Addon) XXX_Size() int {
	return m.Size()
}
func (m *Addon) XXX_DiscardUnknown() {
	xxx_messageInfo_Addon.DiscardUnknown(m)
}

var xxx_messageInfo_Addon proto.InternalMessageInfo

func (m *Addons) Reset()      { *m = Addons{} }
func (*Addons) ProtoMessage() {}
func (*Addons) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{1}
}
func (m *Addons) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Addons) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Addons) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Addons.Merge(m, src)
}
func (m *Addons) XXX_Size() int {
	return m.Size()
}
func (m *Addons) XXX_DiscardUnknown() {
	xxx_messageInfo_Addons.DiscardUnknown(m)
}

var xxx_messageInfo_Addons proto.InternalMessageInfo

func (m *AdmissionPlugin) Reset()      { *m = AdmissionPlugin{} }
func (*AdmissionPlugin) ProtoMessage() {}
func (*AdmissionPlugin) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{2}
}
func (m *AdmissionPlugin) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AdmissionPlugin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AdmissionPlugin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdmissionPlugin.Merge(m, src)
}
func (m *AdmissionPlugin) XXX_Size() int {
	return m.Size()
}
func (m *AdmissionPlugin) XXX_DiscardUnknown() {
	xxx_messageInfo_AdmissionPlugin.DiscardUnknown(m)
}

var xxx_messageInfo_AdmissionPlugin proto.InternalMessageInfo

func (m *Alerting) Reset()      { *m = Alerting{} }
func (*Alerting) ProtoMessage() {}
func (*Alerting) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{3}
}
func (m *Alerting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Alerting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Alerting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Alerting.Merge(m, src)
}
func (m *Alerting) XXX_Size() int {
	return m.Size()
}
func (m *Alerting) XXX_DiscardUnknown() {
	xxx_messageInfo_Alerting.DiscardUnknown(m)
}

var xxx_messageInfo_Alerting proto.InternalMessageInfo

func (m *AuditConfig) Reset()      { *m = AuditConfig{} }
func (*AuditConfig) ProtoMessage() {}
func (*AuditConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{4}
}
func (m *AuditConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AuditConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AuditConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AuditConfig.Merge(m, src)
}
func (m *AuditConfig) XXX_Size() int {
	return m.Size()
}
func (m *AuditConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_AuditConfig.DiscardUnknown(m)
}

var xxx_messageInfo_AuditConfig proto.InternalMessageInfo

func (m *AuditPolicy) Reset()      { *m = AuditPolicy{} }
func (*AuditPolicy) ProtoMessage() {}
func (*AuditPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{5}
}
func (m *AuditPolicy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AuditPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AuditPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AuditPolicy.Merge(m, src)
}
func (m *AuditPolicy) XXX_Size() int {
	return m.Size()
}
func (m *AuditPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_AuditPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_AuditPolicy proto.InternalMessageInfo

func (m *AvailabilityZone) Reset()      { *m = AvailabilityZone{} }
func (*AvailabilityZone) ProtoMessage() {}
func (*AvailabilityZone) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{6}
}
func (m *AvailabilityZone) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AvailabilityZone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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 *BackupBucket) Reset()      { *m = BackupBucket{} }
func (*BackupBucket) ProtoMessage() {}
func (*BackupBucket) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{7}
}
func (m *BackupBucket) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupBucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupBucket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupBucket.Merge(m, src)
}
func (m *BackupBucket) XXX_Size() int {
	return m.Size()
}
func (m *BackupBucket) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupBucket.DiscardUnknown(m)
}

var xxx_messageInfo_BackupBucket proto.InternalMessageInfo

func (m *BackupBucketList) Reset()      { *m = BackupBucketList{} }
func (*BackupBucketList) ProtoMessage() {}
func (*BackupBucketList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{8}
}
func (m *BackupBucketList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupBucketList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupBucketList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupBucketList.Merge(m, src)
}
func (m *BackupBucketList) XXX_Size() int {
	return m.Size()
}
func (m *BackupBucketList) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupBucketList.DiscardUnknown(m)
}

var xxx_messageInfo_BackupBucketList proto.InternalMessageInfo

func (m *BackupBucketProvider) Reset()      { *m = BackupBucketProvider{} }
func (*BackupBucketProvider) ProtoMessage() {}
func (*BackupBucketProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{9}
}
func (m *BackupBucketProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupBucketProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupBucketProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupBucketProvider.Merge(m, src)
}
func (m *BackupBucketProvider) XXX_Size() int {
	return m.Size()
}
func (m *BackupBucketProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupBucketProvider.DiscardUnknown(m)
}

var xxx_messageInfo_BackupBucketProvider proto.InternalMessageInfo

func (m *BackupBucketSpec) Reset()      { *m = BackupBucketSpec{} }
func (*BackupBucketSpec) ProtoMessage() {}
func (*BackupBucketSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{10}
}
func (m *BackupBucketSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupBucketSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupBucketSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupBucketSpec.Merge(m, src)
}
func (m *BackupBucketSpec) XXX_Size() int {
	return m.Size()
}
func (m *BackupBucketSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupBucketSpec.DiscardUnknown(m)
}

var xxx_messageInfo_BackupBucketSpec proto.InternalMessageInfo

func (m *BackupBucketStatus) Reset()      { *m = BackupBucketStatus{} }
func (*BackupBucketStatus) ProtoMessage() {}
func (*BackupBucketStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{11}
}
func (m *BackupBucketStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupBucketStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupBucketStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupBucketStatus.Merge(m, src)
}
func (m *BackupBucketStatus) XXX_Size() int {
	return m.Size()
}
func (m *BackupBucketStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupBucketStatus.DiscardUnknown(m)
}

var xxx_messageInfo_BackupBucketStatus proto.InternalMessageInfo

func (m *BackupEntry) Reset()      { *m = BackupEntry{} }
func (*BackupEntry) ProtoMessage() {}
func (*BackupEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{12}
}
func (m *BackupEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupEntry.Merge(m, src)
}
func (m *BackupEntry) XXX_Size() int {
	return m.Size()
}
func (m *BackupEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupEntry.DiscardUnknown(m)
}

var xxx_messageInfo_BackupEntry proto.InternalMessageInfo

func (m *BackupEntryList) Reset()      { *m = BackupEntryList{} }
func (*BackupEntryList) ProtoMessage() {}
func (*BackupEntryList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{13}
}
func (m *BackupEntryList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupEntryList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupEntryList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupEntryList.Merge(m, src)
}
func (m *BackupEntryList) XXX_Size() int {
	return m.Size()
}
func (m *BackupEntryList) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupEntryList.DiscardUnknown(m)
}

var xxx_messageInfo_BackupEntryList proto.InternalMessageInfo

func (m *BackupEntrySpec) Reset()      { *m = BackupEntrySpec{} }
func (*BackupEntrySpec) ProtoMessage() {}
func (*BackupEntrySpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{14}
}
func (m *BackupEntrySpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupEntrySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupEntrySpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupEntrySpec.Merge(m, src)
}
func (m *BackupEntrySpec) XXX_Size() int {
	return m.Size()
}
func (m *BackupEntrySpec) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupEntrySpec.DiscardUnknown(m)
}

var xxx_messageInfo_BackupEntrySpec proto.InternalMessageInfo

func (m *BackupEntryStatus) Reset()      { *m = BackupEntryStatus{} }
func (*BackupEntryStatus) ProtoMessage() {}
func (*BackupEntryStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{15}
}
func (m *BackupEntryStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BackupEntryStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *BackupEntryStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupEntryStatus.Merge(m, src)
}
func (m *BackupEntryStatus) XXX_Size() int {
	return m.Size()
}
func (m *BackupEntryStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupEntryStatus.DiscardUnknown(m)
}

var xxx_messageInfo_BackupEntryStatus proto.InternalMessageInfo

func (m *CRI) Reset()      { *m = CRI{} }
func (*CRI) ProtoMessage() {}
func (*CRI) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{16}
}
func (m *CRI) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CRI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CRI) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CRI.Merge(m, src)
}
func (m *CRI) XXX_Size() int {
	return m.Size()
}
func (m *CRI) XXX_DiscardUnknown() {
	xxx_messageInfo_CRI.DiscardUnknown(m)
}

var xxx_messageInfo_CRI proto.InternalMessageInfo

func (m *CloudInfo) Reset()      { *m = CloudInfo{} }
func (*CloudInfo) ProtoMessage() {}
func (*CloudInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{17}
}
func (m *CloudInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudInfo.Merge(m, src)
}
func (m *CloudInfo) XXX_Size() int {
	return m.Size()
}
func (m *CloudInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CloudInfo proto.InternalMessageInfo

func (m *CloudProfile) Reset()      { *m = CloudProfile{} }
func (*CloudProfile) ProtoMessage() {}
func (*CloudProfile) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{18}
}
func (m *CloudProfile) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudProfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudProfile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudProfile.Merge(m, src)
}
func (m *CloudProfile) XXX_Size() int {
	return m.Size()
}
func (m *CloudProfile) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudProfile.DiscardUnknown(m)
}

var xxx_messageInfo_CloudProfile proto.InternalMessageInfo

func (m *CloudProfileList) Reset()      { *m = CloudProfileList{} }
func (*CloudProfileList) ProtoMessage() {}
func (*CloudProfileList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{19}
}
func (m *CloudProfileList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudProfileList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudProfileList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudProfileList.Merge(m, src)
}
func (m *CloudProfileList) XXX_Size() int {
	return m.Size()
}
func (m *CloudProfileList) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudProfileList.DiscardUnknown(m)
}

var xxx_messageInfo_CloudProfileList proto.InternalMessageInfo

func (m *CloudProfileSpec) Reset()      { *m = CloudProfileSpec{} }
func (*CloudProfileSpec) ProtoMessage() {}
func (*CloudProfileSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{20}
}
func (m *CloudProfileSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloudProfileSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CloudProfileSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloudProfileSpec.Merge(m, src)
}
func (m *CloudProfileSpec) XXX_Size() int {
	return m.Size()
}
func (m *CloudProfileSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_CloudProfileSpec.DiscardUnknown(m)
}

var xxx_messageInfo_CloudProfileSpec proto.InternalMessageInfo

func (m *ClusterAutoscaler) Reset()      { *m = ClusterAutoscaler{} }
func (*ClusterAutoscaler) ProtoMessage() {}
func (*ClusterAutoscaler) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{21}
}
func (m *ClusterAutoscaler) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterAutoscaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ClusterAutoscaler) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterAutoscaler.Merge(m, src)
}
func (m *ClusterAutoscaler) XXX_Size() int {
	return m.Size()
}
func (m *ClusterAutoscaler) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterAutoscaler.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterAutoscaler proto.InternalMessageInfo

func (m *ClusterInfo) Reset()      { *m = ClusterInfo{} }
func (*ClusterInfo) ProtoMessage() {}
func (*ClusterInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{22}
}
func (m *ClusterInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ClusterInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterInfo.Merge(m, src)
}
func (m *ClusterInfo) XXX_Size() int {
	return m.Size()
}
func (m *ClusterInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterInfo proto.InternalMessageInfo

func (m *Condition) Reset()      { *m = Condition{} }
func (*Condition) ProtoMessage() {}
func (*Condition) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{23}
}
func (m *Condition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Condition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Condition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Condition.Merge(m, src)
}
func (m *Condition) XXX_Size() int {
	return m.Size()
}
func (m *Condition) XXX_DiscardUnknown() {
	xxx_messageInfo_Condition.DiscardUnknown(m)
}

var xxx_messageInfo_Condition proto.InternalMessageInfo

func (m *ContainerRuntime) Reset()      { *m = ContainerRuntime{} }
func (*ContainerRuntime) ProtoMessage() {}
func (*ContainerRuntime) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{24}
}
func (m *ContainerRuntime) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainerRuntime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ContainerRuntime) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerRuntime.Merge(m, src)
}
func (m *ContainerRuntime) XXX_Size() int {
	return m.Size()
}
func (m *ContainerRuntime) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerRuntime.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerRuntime proto.InternalMessageInfo

func (m *ControllerDeployment) Reset()      { *m = ControllerDeployment{} }
func (*ControllerDeployment) ProtoMessage() {}
func (*ControllerDeployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{25}
}
func (m *ControllerDeployment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerDeployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerDeployment.Merge(m, src)
}
func (m *ControllerDeployment) XXX_Size() int {
	return m.Size()
}
func (m *ControllerDeployment) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerDeployment.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerDeployment proto.InternalMessageInfo

func (m *ControllerInstallation) Reset()      { *m = ControllerInstallation{} }
func (*ControllerInstallation) ProtoMessage() {}
func (*ControllerInstallation) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{26}
}
func (m *ControllerInstallation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerInstallation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerInstallation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerInstallation.Merge(m, src)
}
func (m *ControllerInstallation) XXX_Size() int {
	return m.Size()
}
func (m *ControllerInstallation) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerInstallation.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerInstallation proto.InternalMessageInfo

func (m *ControllerInstallationList) Reset()      { *m = ControllerInstallationList{} }
func (*ControllerInstallationList) ProtoMessage() {}
func (*ControllerInstallationList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{27}
}
func (m *ControllerInstallationList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerInstallationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerInstallationList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerInstallationList.Merge(m, src)
}
func (m *ControllerInstallationList) XXX_Size() int {
	return m.Size()
}
func (m *ControllerInstallationList) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerInstallationList.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerInstallationList proto.InternalMessageInfo

func (m *ControllerInstallationSpec) Reset()      { *m = ControllerInstallationSpec{} }
func (*ControllerInstallationSpec) ProtoMessage() {}
func (*ControllerInstallationSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{28}
}
func (m *ControllerInstallationSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerInstallationSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerInstallationSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerInstallationSpec.Merge(m, src)
}
func (m *ControllerInstallationSpec) XXX_Size() int {
	return m.Size()
}
func (m *ControllerInstallationSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerInstallationSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerInstallationSpec proto.InternalMessageInfo

func (m *ControllerInstallationStatus) Reset()      { *m = ControllerInstallationStatus{} }
func (*ControllerInstallationStatus) ProtoMessage() {}
func (*ControllerInstallationStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{29}
}
func (m *ControllerInstallationStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerInstallationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerInstallationStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerInstallationStatus.Merge(m, src)
}
func (m *ControllerInstallationStatus) XXX_Size() int {
	return m.Size()
}
func (m *ControllerInstallationStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerInstallationStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerInstallationStatus proto.InternalMessageInfo

func (m *ControllerRegistration) Reset()      { *m = ControllerRegistration{} }
func (*ControllerRegistration) ProtoMessage() {}
func (*ControllerRegistration) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{30}
}
func (m *ControllerRegistration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerRegistration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerRegistration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerRegistration.Merge(m, src)
}
func (m *ControllerRegistration) XXX_Size() int {
	return m.Size()
}
func (m *ControllerRegistration) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerRegistration.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerRegistration proto.InternalMessageInfo

func (m *ControllerRegistrationList) Reset()      { *m = ControllerRegistrationList{} }
func (*ControllerRegistrationList) ProtoMessage() {}
func (*ControllerRegistrationList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{31}
}
func (m *ControllerRegistrationList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerRegistrationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerRegistrationList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerRegistrationList.Merge(m, src)
}
func (m *ControllerRegistrationList) XXX_Size() int {
	return m.Size()
}
func (m *ControllerRegistrationList) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerRegistrationList.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerRegistrationList proto.InternalMessageInfo

func (m *ControllerRegistrationSpec) Reset()      { *m = ControllerRegistrationSpec{} }
func (*ControllerRegistrationSpec) ProtoMessage() {}
func (*ControllerRegistrationSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{32}
}
func (m *ControllerRegistrationSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerRegistrationSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerRegistrationSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerRegistrationSpec.Merge(m, src)
}
func (m *ControllerRegistrationSpec) XXX_Size() int {
	return m.Size()
}
func (m *ControllerRegistrationSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerRegistrationSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerRegistrationSpec proto.InternalMessageInfo

func (m *ControllerResource) Reset()      { *m = ControllerResource{} }
func (*ControllerResource) ProtoMessage() {}
func (*ControllerResource) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{33}
}
func (m *ControllerResource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControllerResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ControllerResource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControllerResource.Merge(m, src)
}
func (m *ControllerResource) XXX_Size() int {
	return m.Size()
}
func (m *ControllerResource) XXX_DiscardUnknown() {
	xxx_messageInfo_ControllerResource.DiscardUnknown(m)
}

var xxx_messageInfo_ControllerResource proto.InternalMessageInfo

func (m *DNS) Reset()      { *m = DNS{} }
func (*DNS) ProtoMessage() {}
func (*DNS) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{34}
}
func (m *DNS) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DNS) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNS.Merge(m, src)
}
func (m *DNS) XXX_Size() int {
	return m.Size()
}
func (m *DNS) XXX_DiscardUnknown() {
	xxx_messageInfo_DNS.DiscardUnknown(m)
}

var xxx_messageInfo_DNS proto.InternalMessageInfo

func (m *DNSIncludeExclude) Reset()      { *m = DNSIncludeExclude{} }
func (*DNSIncludeExclude) ProtoMessage() {}
func (*DNSIncludeExclude) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{35}
}
func (m *DNSIncludeExclude) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNSIncludeExclude) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DNSIncludeExclude) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNSIncludeExclude.Merge(m, src)
}
func (m *DNSIncludeExclude) XXX_Size() int {
	return m.Size()
}
func (m *DNSIncludeExclude) XXX_DiscardUnknown() {
	xxx_messageInfo_DNSIncludeExclude.DiscardUnknown(m)
}

var xxx_messageInfo_DNSIncludeExclude proto.InternalMessageInfo

func (m *DNSProvider) Reset()      { *m = DNSProvider{} }
func (*DNSProvider) ProtoMessage() {}
func (*DNSProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{36}
}
func (m *DNSProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNSProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DNSProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNSProvider.Merge(m, src)
}
func (m *DNSProvider) XXX_Size() int {
	return m.Size()
}
func (m *DNSProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_DNSProvider.DiscardUnknown(m)
}

var xxx_messageInfo_DNSProvider proto.InternalMessageInfo

func (m *DataVolume) Reset()      { *m = DataVolume{} }
func (*DataVolume) ProtoMessage() {}
func (*DataVolume) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{37}
}
func (m *DataVolume) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DataVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *DataVolume) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataVolume.Merge(m, src)
}
func (m *DataVolume) XXX_Size() int {
	return m.Size()
}
func (m *DataVolume) XXX_DiscardUnknown() {
	xxx_messageInfo_DataVolume.DiscardUnknown(m)
}

var xxx_messageInfo_DataVolume proto.InternalMessageInfo

func (m *Endpoint) Reset()      { *m = Endpoint{} }
func (*Endpoint) ProtoMessage() {}
func (*Endpoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{38}
}
func (m *Endpoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Endpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Endpoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Endpoint.Merge(m, src)
}
func (m *Endpoint) XXX_Size() int {
	return m.Size()
}
func (m *Endpoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Endpoint.DiscardUnknown(m)
}

var xxx_messageInfo_Endpoint proto.InternalMessageInfo

func (m *ExpirableVersion) Reset()      { *m = ExpirableVersion{} }
func (*ExpirableVersion) ProtoMessage() {}
func (*ExpirableVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{39}
}
func (m *ExpirableVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExpirableVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ExpirableVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExpirableVersion.Merge(m, src)
}
func (m *ExpirableVersion) XXX_Size() int {
	return m.Size()
}
func (m *ExpirableVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_ExpirableVersion.DiscardUnknown(m)
}

var xxx_messageInfo_ExpirableVersion proto.InternalMessageInfo

func (m *Extension) Reset()      { *m = Extension{} }
func (*Extension) ProtoMessage() {}
func (*Extension) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{40}
}
func (m *Extension) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Extension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Extension) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Extension.Merge(m, src)
}
func (m *Extension) XXX_Size() int {
	return m.Size()
}
func (m *Extension) XXX_DiscardUnknown() {
	xxx_messageInfo_Extension.DiscardUnknown(m)
}

var xxx_messageInfo_Extension proto.InternalMessageInfo

func (m *ExtensionResourceState) Reset()      { *m = ExtensionResourceState{} }
func (*ExtensionResourceState) ProtoMessage() {}
func (*ExtensionResourceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{41}
}
func (m *ExtensionResourceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExtensionResourceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ExtensionResourceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtensionResourceState.Merge(m, src)
}
func (m *ExtensionResourceState) XXX_Size() int {
	return m.Size()
}
func (m *ExtensionResourceState) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtensionResourceState.DiscardUnknown(m)
}

var xxx_messageInfo_ExtensionResourceState proto.InternalMessageInfo

func (m *Gardener) Reset()      { *m = Gardener{} }
func (*Gardener) ProtoMessage() {}
func (*Gardener) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{42}
}
func (m *Gardener) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Gardener) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Gardener) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Gardener.Merge(m, src)
}
func (m *Gardener) XXX_Size() int {
	return m.Size()
}
func (m *Gardener) XXX_DiscardUnknown() {
	xxx_messageInfo_Gardener.DiscardUnknown(m)
}

var xxx_messageInfo_Gardener proto.InternalMessageInfo

func (m *GardenerResourceData) Reset()      { *m = GardenerResourceData{} }
func (*GardenerResourceData) ProtoMessage() {}
func (*GardenerResourceData) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{43}
}
func (m *GardenerResourceData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GardenerResourceData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *GardenerResourceData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GardenerResourceData.Merge(m, src)
}
func (m *GardenerResourceData) XXX_Size() int {
	return m.Size()
}
func (m *GardenerResourceData) XXX_DiscardUnknown() {
	xxx_messageInfo_GardenerResourceData.DiscardUnknown(m)
}

var xxx_messageInfo_GardenerResourceData proto.InternalMessageInfo

func (m *Hibernation) Reset()      { *m = Hibernation{} }
func (*Hibernation) ProtoMessage() {}
func (*Hibernation) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{44}
}
func (m *Hibernation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Hibernation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Hibernation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Hibernation.Merge(m, src)
}
func (m *Hibernation) XXX_Size() int {
	return m.Size()
}
func (m *Hibernation) XXX_DiscardUnknown() {
	xxx_messageInfo_Hibernation.DiscardUnknown(m)
}

var xxx_messageInfo_Hibernation proto.InternalMessageInfo

func (m *HibernationSchedule) Reset()      { *m = HibernationSchedule{} }
func (*HibernationSchedule) ProtoMessage() {}
func (*HibernationSchedule) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{45}
}
func (m *HibernationSchedule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HibernationSchedule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *HibernationSchedule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HibernationSchedule.Merge(m, src)
}
func (m *HibernationSchedule) XXX_Size() int {
	return m.Size()
}
func (m *HibernationSchedule) XXX_DiscardUnknown() {
	xxx_messageInfo_HibernationSchedule.DiscardUnknown(m)
}

var xxx_messageInfo_HibernationSchedule proto.InternalMessageInfo

func (m *HorizontalPodAutoscalerConfig) Reset()      { *m = HorizontalPodAutoscalerConfig{} }
func (*HorizontalPodAutoscalerConfig) ProtoMessage() {}
func (*HorizontalPodAutoscalerConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{46}
}
func (m *HorizontalPodAutoscalerConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HorizontalPodAutoscalerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *HorizontalPodAutoscalerConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HorizontalPodAutoscalerConfig.Merge(m, src)
}
func (m *HorizontalPodAutoscalerConfig) XXX_Size() int {
	return m.Size()
}
func (m *HorizontalPodAutoscalerConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_HorizontalPodAutoscalerConfig.DiscardUnknown(m)
}

var xxx_messageInfo_HorizontalPodAutoscalerConfig proto.InternalMessageInfo

func (m *Ingress) Reset()      { *m = Ingress{} }
func (*Ingress) ProtoMessage() {}
func (*Ingress) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{47}
}
func (m *Ingress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Ingress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Ingress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Ingress.Merge(m, src)
}
func (m *Ingress) XXX_Size() int {
	return m.Size()
}
func (m *Ingress) XXX_DiscardUnknown() {
	xxx_messageInfo_Ingress.DiscardUnknown(m)
}

var xxx_messageInfo_Ingress proto.InternalMessageInfo

func (m *IngressController) Reset()      { *m = IngressController{} }
func (*IngressController) ProtoMessage() {}
func (*IngressController) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{48}
}
func (m *IngressController) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IngressController) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *IngressController) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IngressController.Merge(m, src)
}
func (m *IngressController) XXX_Size() int {
	return m.Size()
}
func (m *IngressController) XXX_DiscardUnknown() {
	xxx_messageInfo_IngressController.DiscardUnknown(m)
}

var xxx_messageInfo_IngressController proto.InternalMessageInfo

func (m *KubeAPIServerConfig) Reset()      { *m = KubeAPIServerConfig{} }
func (*KubeAPIServerConfig) ProtoMessage() {}
func (*KubeAPIServerConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{49}
}
func (m *KubeAPIServerConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeAPIServerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeAPIServerConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeAPIServerConfig.Merge(m, src)
}
func (m *KubeAPIServerConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubeAPIServerConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeAPIServerConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubeAPIServerConfig proto.InternalMessageInfo

func (m *KubeAPIServerRequests) Reset()      { *m = KubeAPIServerRequests{} }
func (*KubeAPIServerRequests) ProtoMessage() {}
func (*KubeAPIServerRequests) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{50}
}
func (m *KubeAPIServerRequests) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeAPIServerRequests) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeAPIServerRequests) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeAPIServerRequests.Merge(m, src)
}
func (m *KubeAPIServerRequests) XXX_Size() int {
	return m.Size()
}
func (m *KubeAPIServerRequests) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeAPIServerRequests.DiscardUnknown(m)
}

var xxx_messageInfo_KubeAPIServerRequests proto.InternalMessageInfo

func (m *KubeControllerManagerConfig) Reset()      { *m = KubeControllerManagerConfig{} }
func (*KubeControllerManagerConfig) ProtoMessage() {}
func (*KubeControllerManagerConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{51}
}
func (m *KubeControllerManagerConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeControllerManagerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeControllerManagerConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeControllerManagerConfig.Merge(m, src)
}
func (m *KubeControllerManagerConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubeControllerManagerConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeControllerManagerConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubeControllerManagerConfig proto.InternalMessageInfo

func (m *KubeProxyConfig) Reset()      { *m = KubeProxyConfig{} }
func (*KubeProxyConfig) ProtoMessage() {}
func (*KubeProxyConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{52}
}
func (m *KubeProxyConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeProxyConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeProxyConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeProxyConfig.Merge(m, src)
}
func (m *KubeProxyConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubeProxyConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeProxyConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubeProxyConfig proto.InternalMessageInfo

func (m *KubeSchedulerConfig) Reset()      { *m = KubeSchedulerConfig{} }
func (*KubeSchedulerConfig) ProtoMessage() {}
func (*KubeSchedulerConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{53}
}
func (m *KubeSchedulerConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeSchedulerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeSchedulerConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeSchedulerConfig.Merge(m, src)
}
func (m *KubeSchedulerConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubeSchedulerConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeSchedulerConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubeSchedulerConfig proto.InternalMessageInfo

func (m *KubeletConfig) Reset()      { *m = KubeletConfig{} }
func (*KubeletConfig) ProtoMessage() {}
func (*KubeletConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{54}
}
func (m *KubeletConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeletConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeletConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeletConfig.Merge(m, src)
}
func (m *KubeletConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubeletConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeletConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubeletConfig proto.InternalMessageInfo

func (m *KubeletConfigEviction) Reset()      { *m = KubeletConfigEviction{} }
func (*KubeletConfigEviction) ProtoMessage() {}
func (*KubeletConfigEviction) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{55}
}
func (m *KubeletConfigEviction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeletConfigEviction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeletConfigEviction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeletConfigEviction.Merge(m, src)
}
func (m *KubeletConfigEviction) XXX_Size() int {
	return m.Size()
}
func (m *KubeletConfigEviction) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeletConfigEviction.DiscardUnknown(m)
}

var xxx_messageInfo_KubeletConfigEviction proto.InternalMessageInfo

func (m *KubeletConfigEvictionMinimumReclaim) Reset()      { *m = KubeletConfigEvictionMinimumReclaim{} }
func (*KubeletConfigEvictionMinimumReclaim) ProtoMessage() {}
func (*KubeletConfigEvictionMinimumReclaim) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{56}
}
func (m *KubeletConfigEvictionMinimumReclaim) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeletConfigEvictionMinimumReclaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeletConfigEvictionMinimumReclaim) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeletConfigEvictionMinimumReclaim.Merge(m, src)
}
func (m *KubeletConfigEvictionMinimumReclaim) XXX_Size() int {
	return m.Size()
}
func (m *KubeletConfigEvictionMinimumReclaim) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeletConfigEvictionMinimumReclaim.DiscardUnknown(m)
}

var xxx_messageInfo_KubeletConfigEvictionMinimumReclaim proto.InternalMessageInfo

func (m *KubeletConfigEvictionSoftGracePeriod) Reset()      { *m = KubeletConfigEvictionSoftGracePeriod{} }
func (*KubeletConfigEvictionSoftGracePeriod) ProtoMessage() {}
func (*KubeletConfigEvictionSoftGracePeriod) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{57}
}
func (m *KubeletConfigEvictionSoftGracePeriod) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeletConfigEvictionSoftGracePeriod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeletConfigEvictionSoftGracePeriod) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeletConfigEvictionSoftGracePeriod.Merge(m, src)
}
func (m *KubeletConfigEvictionSoftGracePeriod) XXX_Size() int {
	return m.Size()
}
func (m *KubeletConfigEvictionSoftGracePeriod) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeletConfigEvictionSoftGracePeriod.DiscardUnknown(m)
}

var xxx_messageInfo_KubeletConfigEvictionSoftGracePeriod proto.InternalMessageInfo

func (m *KubeletConfigReserved) Reset()      { *m = KubeletConfigReserved{} }
func (*KubeletConfigReserved) ProtoMessage() {}
func (*KubeletConfigReserved) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{58}
}
func (m *KubeletConfigReserved) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubeletConfigReserved) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubeletConfigReserved) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubeletConfigReserved.Merge(m, src)
}
func (m *KubeletConfigReserved) XXX_Size() int {
	return m.Size()
}
func (m *KubeletConfigReserved) XXX_DiscardUnknown() {
	xxx_messageInfo_KubeletConfigReserved.DiscardUnknown(m)
}

var xxx_messageInfo_KubeletConfigReserved proto.InternalMessageInfo

func (m *Kubernetes) Reset()      { *m = Kubernetes{} }
func (*Kubernetes) ProtoMessage() {}
func (*Kubernetes) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{59}
}
func (m *Kubernetes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Kubernetes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Kubernetes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Kubernetes.Merge(m, src)
}
func (m *Kubernetes) XXX_Size() int {
	return m.Size()
}
func (m *Kubernetes) XXX_DiscardUnknown() {
	xxx_messageInfo_Kubernetes.DiscardUnknown(m)
}

var xxx_messageInfo_Kubernetes proto.InternalMessageInfo

func (m *KubernetesConfig) Reset()      { *m = KubernetesConfig{} }
func (*KubernetesConfig) ProtoMessage() {}
func (*KubernetesConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{60}
}
func (m *KubernetesConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubernetesConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubernetesConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubernetesConfig.Merge(m, src)
}
func (m *KubernetesConfig) XXX_Size() int {
	return m.Size()
}
func (m *KubernetesConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_KubernetesConfig.DiscardUnknown(m)
}

var xxx_messageInfo_KubernetesConfig proto.InternalMessageInfo

func (m *KubernetesDashboard) Reset()      { *m = KubernetesDashboard{} }
func (*KubernetesDashboard) ProtoMessage() {}
func (*KubernetesDashboard) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{61}
}
func (m *KubernetesDashboard) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubernetesDashboard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubernetesDashboard) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubernetesDashboard.Merge(m, src)
}
func (m *KubernetesDashboard) XXX_Size() int {
	return m.Size()
}
func (m *KubernetesDashboard) XXX_DiscardUnknown() {
	xxx_messageInfo_KubernetesDashboard.DiscardUnknown(m)
}

var xxx_messageInfo_KubernetesDashboard proto.InternalMessageInfo

func (m *KubernetesInfo) Reset()      { *m = KubernetesInfo{} }
func (*KubernetesInfo) ProtoMessage() {}
func (*KubernetesInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{62}
}
func (m *KubernetesInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubernetesInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubernetesInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubernetesInfo.Merge(m, src)
}
func (m *KubernetesInfo) XXX_Size() int {
	return m.Size()
}
func (m *KubernetesInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_KubernetesInfo.DiscardUnknown(m)
}

var xxx_messageInfo_KubernetesInfo proto.InternalMessageInfo

func (m *KubernetesSettings) Reset()      { *m = KubernetesSettings{} }
func (*KubernetesSettings) ProtoMessage() {}
func (*KubernetesSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{63}
}
func (m *KubernetesSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KubernetesSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *KubernetesSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KubernetesSettings.Merge(m, src)
}
func (m *KubernetesSettings) XXX_Size() int {
	return m.Size()
}
func (m *KubernetesSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_KubernetesSettings.DiscardUnknown(m)
}

var xxx_messageInfo_KubernetesSettings proto.InternalMessageInfo

func (m *LastError) Reset()      { *m = LastError{} }
func (*LastError) ProtoMessage() {}
func (*LastError) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{64}
}
func (m *LastError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LastError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *LastError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastError.Merge(m, src)
}
func (m *LastError) XXX_Size() int {
	return m.Size()
}
func (m *LastError) XXX_DiscardUnknown() {
	xxx_messageInfo_LastError.DiscardUnknown(m)
}

var xxx_messageInfo_LastError proto.InternalMessageInfo

func (m *LastOperation) Reset()      { *m = LastOperation{} }
func (*LastOperation) ProtoMessage() {}
func (*LastOperation) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{65}
}
func (m *LastOperation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LastOperation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *LastOperation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastOperation.Merge(m, src)
}
func (m *LastOperation) XXX_Size() int {
	return m.Size()
}
func (m *LastOperation) XXX_DiscardUnknown() {
	xxx_messageInfo_LastOperation.DiscardUnknown(m)
}

var xxx_messageInfo_LastOperation proto.InternalMessageInfo

func (m *Machine) Reset()      { *m = Machine{} }
func (*Machine) ProtoMessage() {}
func (*Machine) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{66}
}
func (m *Machine) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Machine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Machine) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Machine.Merge(m, src)
}
func (m *Machine) XXX_Size() int {
	return m.Size()
}
func (m *Machine) XXX_DiscardUnknown() {
	xxx_messageInfo_Machine.DiscardUnknown(m)
}

var xxx_messageInfo_Machine proto.InternalMessageInfo

func (m *MachineControllerManagerSettings) Reset()      { *m = MachineControllerManagerSettings{} }
func (*MachineControllerManagerSettings) ProtoMessage() {}
func (*MachineControllerManagerSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{67}
}
func (m *MachineControllerManagerSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MachineControllerManagerSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MachineControllerManagerSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MachineControllerManagerSettings.Merge(m, src)
}
func (m *MachineControllerManagerSettings) XXX_Size() int {
	return m.Size()
}
func (m *MachineControllerManagerSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_MachineControllerManagerSettings.DiscardUnknown(m)
}

var xxx_messageInfo_MachineControllerManagerSettings proto.InternalMessageInfo

func (m *MachineImage) Reset()      { *m = MachineImage{} }
func (*MachineImage) ProtoMessage() {}
func (*MachineImage) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{68}
}
func (m *MachineImage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MachineImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MachineImage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MachineImage.Merge(m, src)
}
func (m *MachineImage) XXX_Size() int {
	return m.Size()
}
func (m *MachineImage) XXX_DiscardUnknown() {
	xxx_messageInfo_MachineImage.DiscardUnknown(m)
}

var xxx_messageInfo_MachineImage proto.InternalMessageInfo

func (m *MachineImageVersion) Reset()      { *m = MachineImageVersion{} }
func (*MachineImageVersion) ProtoMessage() {}
func (*MachineImageVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{69}
}
func (m *MachineImageVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MachineImageVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MachineImageVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MachineImageVersion.Merge(m, src)
}
func (m *MachineImageVersion) XXX_Size() int {
	return m.Size()
}
func (m *MachineImageVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_MachineImageVersion.DiscardUnknown(m)
}

var xxx_messageInfo_MachineImageVersion proto.InternalMessageInfo

func (m *MachineType) Reset()      { *m = MachineType{} }
func (*MachineType) ProtoMessage() {}
func (*MachineType) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{70}
}
func (m *MachineType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MachineType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MachineType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MachineType.Merge(m, src)
}
func (m *MachineType) XXX_Size() int {
	return m.Size()
}
func (m *MachineType) XXX_DiscardUnknown() {
	xxx_messageInfo_MachineType.DiscardUnknown(m)
}

var xxx_messageInfo_MachineType proto.InternalMessageInfo

func (m *MachineTypeStorage) Reset()      { *m = MachineTypeStorage{} }
func (*MachineTypeStorage) ProtoMessage() {}
func (*MachineTypeStorage) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{71}
}
func (m *MachineTypeStorage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MachineTypeStorage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MachineTypeStorage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MachineTypeStorage.Merge(m, src)
}
func (m *MachineTypeStorage) XXX_Size() int {
	return m.Size()
}
func (m *MachineTypeStorage) XXX_DiscardUnknown() {
	xxx_messageInfo_MachineTypeStorage.DiscardUnknown(m)
}

var xxx_messageInfo_MachineTypeStorage proto.InternalMessageInfo

func (m *Maintenance) Reset()      { *m = Maintenance{} }
func (*Maintenance) ProtoMessage() {}
func (*Maintenance) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{72}
}
func (m *Maintenance) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Maintenance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Maintenance) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Maintenance.Merge(m, src)
}
func (m *Maintenance) XXX_Size() int {
	return m.Size()
}
func (m *Maintenance) XXX_DiscardUnknown() {
	xxx_messageInfo_Maintenance.DiscardUnknown(m)
}

var xxx_messageInfo_Maintenance proto.InternalMessageInfo

func (m *MaintenanceAutoUpdate) Reset()      { *m = MaintenanceAutoUpdate{} }
func (*MaintenanceAutoUpdate) ProtoMessage() {}
func (*MaintenanceAutoUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{73}
}
func (m *MaintenanceAutoUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintenanceAutoUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MaintenanceAutoUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintenanceAutoUpdate.Merge(m, src)
}
func (m *MaintenanceAutoUpdate) XXX_Size() int {
	return m.Size()
}
func (m *MaintenanceAutoUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintenanceAutoUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_MaintenanceAutoUpdate proto.InternalMessageInfo

func (m *MaintenanceTimeWindow) Reset()      { *m = MaintenanceTimeWindow{} }
func (*MaintenanceTimeWindow) ProtoMessage() {}
func (*MaintenanceTimeWindow) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{74}
}
func (m *MaintenanceTimeWindow) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MaintenanceTimeWindow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *MaintenanceTimeWindow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaintenanceTimeWindow.Merge(m, src)
}
func (m *MaintenanceTimeWindow) XXX_Size() int {
	return m.Size()
}
func (m *MaintenanceTimeWindow) XXX_DiscardUnknown() {
	xxx_messageInfo_MaintenanceTimeWindow.DiscardUnknown(m)
}

var xxx_messageInfo_MaintenanceTimeWindow proto.InternalMessageInfo

func (m *Monitoring) Reset()      { *m = Monitoring{} }
func (*Monitoring) ProtoMessage() {}
func (*Monitoring) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{75}
}
func (m *Monitoring) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Monitoring) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Monitoring) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Monitoring.Merge(m, src)
}
func (m *Monitoring) XXX_Size() int {
	return m.Size()
}
func (m *Monitoring) XXX_DiscardUnknown() {
	xxx_messageInfo_Monitoring.DiscardUnknown(m)
}

var xxx_messageInfo_Monitoring proto.InternalMessageInfo

func (m *NamedResourceReference) Reset()      { *m = NamedResourceReference{} }
func (*NamedResourceReference) ProtoMessage() {}
func (*NamedResourceReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{76}
}
func (m *NamedResourceReference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NamedResourceReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *NamedResourceReference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NamedResourceReference.Merge(m, src)
}
func (m *NamedResourceReference) XXX_Size() int {
	return m.Size()
}
func (m *NamedResourceReference) XXX_DiscardUnknown() {
	xxx_messageInfo_NamedResourceReference.DiscardUnknown(m)
}

var xxx_messageInfo_NamedResourceReference proto.InternalMessageInfo

func (m *Networking) Reset()      { *m = Networking{} }
func (*Networking) ProtoMessage() {}
func (*Networking) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{77}
}
func (m *Networking) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Networking) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Networking) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Networking.Merge(m, src)
}
func (m *Networking) XXX_Size() int {
	return m.Size()
}
func (m *Networking) XXX_DiscardUnknown() {
	xxx_messageInfo_Networking.DiscardUnknown(m)
}

var xxx_messageInfo_Networking proto.InternalMessageInfo

func (m *NginxIngress) Reset()      { *m = NginxIngress{} }
func (*NginxIngress) ProtoMessage() {}
func (*NginxIngress) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{78}
}
func (m *NginxIngress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NginxIngress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *NginxIngress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NginxIngress.Merge(m, src)
}
func (m *NginxIngress) XXX_Size() int {
	return m.Size()
}
func (m *NginxIngress) XXX_DiscardUnknown() {
	xxx_messageInfo_NginxIngress.DiscardUnknown(m)
}

var xxx_messageInfo_NginxIngress proto.InternalMessageInfo

func (m *OIDCConfig) Reset()      { *m = OIDCConfig{} }
func (*OIDCConfig) ProtoMessage() {}
func (*OIDCConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{79}
}
func (m *OIDCConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OIDCConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *OIDCConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OIDCConfig.Merge(m, src)
}
func (m *OIDCConfig) XXX_Size() int {
	return m.Size()
}
func (m *OIDCConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_OIDCConfig.DiscardUnknown(m)
}

var xxx_messageInfo_OIDCConfig proto.InternalMessageInfo

func (m *OpenIDConnectClientAuthentication) Reset()      { *m = OpenIDConnectClientAuthentication{} }
func (*OpenIDConnectClientAuthentication) ProtoMessage() {}
func (*OpenIDConnectClientAuthentication) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{80}
}
func (m *OpenIDConnectClientAuthentication) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OpenIDConnectClientAuthentication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *OpenIDConnectClientAuthentication) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenIDConnectClientAuthentication.Merge(m, src)
}
func (m *OpenIDConnectClientAuthentication) XXX_Size() int {
	return m.Size()
}
func (m *OpenIDConnectClientAuthentication) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenIDConnectClientAuthentication.DiscardUnknown(m)
}

var xxx_messageInfo_OpenIDConnectClientAuthentication proto.InternalMessageInfo

func (m *Plant) Reset()      { *m = Plant{} }
func (*Plant) ProtoMessage() {}
func (*Plant) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{81}
}
func (m *Plant) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Plant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Plant) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Plant.Merge(m, src)
}
func (m *Plant) XXX_Size() int {
	return m.Size()
}
func (m *Plant) XXX_DiscardUnknown() {
	xxx_messageInfo_Plant.DiscardUnknown(m)
}

var xxx_messageInfo_Plant proto.InternalMessageInfo

func (m *PlantList) Reset()      { *m = PlantList{} }
func (*PlantList) ProtoMessage() {}
func (*PlantList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{82}
}
func (m *PlantList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PlantList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *PlantList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PlantList.Merge(m, src)
}
func (m *PlantList) XXX_Size() int {
	return m.Size()
}
func (m *PlantList) XXX_DiscardUnknown() {
	xxx_messageInfo_PlantList.DiscardUnknown(m)
}

var xxx_messageInfo_PlantList proto.InternalMessageInfo

func (m *PlantSpec) Reset()      { *m = PlantSpec{} }
func (*PlantSpec) ProtoMessage() {}
func (*PlantSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{83}
}
func (m *PlantSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PlantSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *PlantSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PlantSpec.Merge(m, src)
}
func (m *PlantSpec) XXX_Size() int {
	return m.Size()
}
func (m *PlantSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_PlantSpec.DiscardUnknown(m)
}

var xxx_messageInfo_PlantSpec proto.InternalMessageInfo

func (m *PlantStatus) Reset()      { *m = PlantStatus{} }
func (*PlantStatus) ProtoMessage() {}
func (*PlantStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{84}
}
func (m *PlantStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PlantStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *PlantStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PlantStatus.Merge(m, src)
}
func (m *PlantStatus) XXX_Size() int {
	return m.Size()
}
func (m *PlantStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_PlantStatus.DiscardUnknown(m)
}

var xxx_messageInfo_PlantStatus proto.InternalMessageInfo

func (m *Project) Reset()      { *m = Project{} }
func (*Project) ProtoMessage() {}
func (*Project) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{85}
}
func (m *Project) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Project) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Project) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Project.Merge(m, src)
}
func (m *Project) XXX_Size() int {
	return m.Size()
}
func (m *Project) XXX_DiscardUnknown() {
	xxx_messageInfo_Project.DiscardUnknown(m)
}

var xxx_messageInfo_Project proto.InternalMessageInfo

func (m *ProjectList) Reset()      { *m = ProjectList{} }
func (*ProjectList) ProtoMessage() {}
func (*ProjectList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{86}
}
func (m *ProjectList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProjectList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ProjectList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProjectList.Merge(m, src)
}
func (m *ProjectList) XXX_Size() int {
	return m.Size()
}
func (m *ProjectList) XXX_DiscardUnknown() {
	xxx_messageInfo_ProjectList.DiscardUnknown(m)
}

var xxx_messageInfo_ProjectList proto.InternalMessageInfo

func (m *ProjectMember) Reset()      { *m = ProjectMember{} }
func (*ProjectMember) ProtoMessage() {}
func (*ProjectMember) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{87}
}
func (m *ProjectMember) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProjectMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ProjectMember) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProjectMember.Merge(m, src)
}
func (m *ProjectMember) XXX_Size() int {
	return m.Size()
}
func (m *ProjectMember) XXX_DiscardUnknown() {
	xxx_messageInfo_ProjectMember.DiscardUnknown(m)
}

var xxx_messageInfo_ProjectMember proto.InternalMessageInfo

func (m *ProjectSpec) Reset()      { *m = ProjectSpec{} }
func (*ProjectSpec) ProtoMessage() {}
func (*ProjectSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{88}
}
func (m *ProjectSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProjectSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ProjectSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProjectSpec.Merge(m, src)
}
func (m *ProjectSpec) XXX_Size() int {
	return m.Size()
}
func (m *ProjectSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ProjectSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ProjectSpec proto.InternalMessageInfo

func (m *ProjectStatus) Reset()      { *m = ProjectStatus{} }
func (*ProjectStatus) ProtoMessage() {}
func (*ProjectStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{89}
}
func (m *ProjectStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProjectStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ProjectStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProjectStatus.Merge(m, src)
}
func (m *ProjectStatus) XXX_Size() int {
	return m.Size()
}
func (m *ProjectStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ProjectStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ProjectStatus proto.InternalMessageInfo

func (m *ProjectTolerations) Reset()      { *m = ProjectTolerations{} }
func (*ProjectTolerations) ProtoMessage() {}
func (*ProjectTolerations) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{90}
}
func (m *ProjectTolerations) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProjectTolerations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ProjectTolerations) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProjectTolerations.Merge(m, src)
}
func (m *ProjectTolerations) XXX_Size() int {
	return m.Size()
}
func (m *ProjectTolerations) XXX_DiscardUnknown() {
	xxx_messageInfo_ProjectTolerations.DiscardUnknown(m)
}

var xxx_messageInfo_ProjectTolerations proto.InternalMessageInfo

func (m *Provider) Reset()      { *m = Provider{} }
func (*Provider) ProtoMessage() {}
func (*Provider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{91}
}
func (m *Provider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Provider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Provider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Provider.Merge(m, src)
}
func (m *Provider) XXX_Size() int {
	return m.Size()
}
func (m *Provider) XXX_DiscardUnknown() {
	xxx_messageInfo_Provider.DiscardUnknown(m)
}

var xxx_messageInfo_Provider proto.InternalMessageInfo

func (m *Quota) Reset()      { *m = Quota{} }
func (*Quota) ProtoMessage() {}
func (*Quota) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{92}
}
func (m *Quota) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Quota) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Quota) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Quota.Merge(m, src)
}
func (m *Quota) XXX_Size() int {
	return m.Size()
}
func (m *Quota) XXX_DiscardUnknown() {
	xxx_messageInfo_Quota.DiscardUnknown(m)
}

var xxx_messageInfo_Quota proto.InternalMessageInfo

func (m *QuotaList) Reset()      { *m = QuotaList{} }
func (*QuotaList) ProtoMessage() {}
func (*QuotaList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{93}
}
func (m *QuotaList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QuotaList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *QuotaList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QuotaList.Merge(m, src)
}
func (m *QuotaList) XXX_Size() int {
	return m.Size()
}
func (m *QuotaList) XXX_DiscardUnknown() {
	xxx_messageInfo_QuotaList.DiscardUnknown(m)
}

var xxx_messageInfo_QuotaList proto.InternalMessageInfo

func (m *QuotaSpec) Reset()      { *m = QuotaSpec{} }
func (*QuotaSpec) ProtoMessage() {}
func (*QuotaSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{94}
}
func (m *QuotaSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QuotaSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *QuotaSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QuotaSpec.Merge(m, src)
}
func (m *QuotaSpec) XXX_Size() int {
	return m.Size()
}
func (m *QuotaSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_QuotaSpec.DiscardUnknown(m)
}

var xxx_messageInfo_QuotaSpec proto.InternalMessageInfo

func (m *Region) Reset()      { *m = Region{} }
func (*Region) ProtoMessage() {}
func (*Region) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{95}
}
func (m *Region) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Region) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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 *ResourceData) Reset()      { *m = ResourceData{} }
func (*ResourceData) ProtoMessage() {}
func (*ResourceData) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{96}
}
func (m *ResourceData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ResourceData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceData.Merge(m, src)
}
func (m *ResourceData) XXX_Size() int {
	return m.Size()
}
func (m *ResourceData) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceData.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceData proto.InternalMessageInfo

func (m *ResourceWatchCacheSize) Reset()      { *m = ResourceWatchCacheSize{} }
func (*ResourceWatchCacheSize) ProtoMessage() {}
func (*ResourceWatchCacheSize) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{97}
}
func (m *ResourceWatchCacheSize) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceWatchCacheSize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ResourceWatchCacheSize) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceWatchCacheSize.Merge(m, src)
}
func (m *ResourceWatchCacheSize) XXX_Size() int {
	return m.Size()
}
func (m *ResourceWatchCacheSize) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceWatchCacheSize.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceWatchCacheSize proto.InternalMessageInfo

func (m *SecretBinding) Reset()      { *m = SecretBinding{} }
func (*SecretBinding) ProtoMessage() {}
func (*SecretBinding) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{98}
}
func (m *SecretBinding) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SecretBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SecretBinding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SecretBinding.Merge(m, src)
}
func (m *SecretBinding) XXX_Size() int {
	return m.Size()
}
func (m *SecretBinding) XXX_DiscardUnknown() {
	xxx_messageInfo_SecretBinding.DiscardUnknown(m)
}

var xxx_messageInfo_SecretBinding proto.InternalMessageInfo

func (m *SecretBindingList) Reset()      { *m = SecretBindingList{} }
func (*SecretBindingList) ProtoMessage() {}
func (*SecretBindingList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{99}
}
func (m *SecretBindingList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SecretBindingList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SecretBindingList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SecretBindingList.Merge(m, src)
}
func (m *SecretBindingList) XXX_Size() int {
	return m.Size()
}
func (m *SecretBindingList) XXX_DiscardUnknown() {
	xxx_messageInfo_SecretBindingList.DiscardUnknown(m)
}

var xxx_messageInfo_SecretBindingList proto.InternalMessageInfo

func (m *Seed) Reset()      { *m = Seed{} }
func (*Seed) ProtoMessage() {}
func (*Seed) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{100}
}
func (m *Seed) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Seed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Seed) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Seed.Merge(m, src)
}
func (m *Seed) XXX_Size() int {
	return m.Size()
}
func (m *Seed) XXX_DiscardUnknown() {
	xxx_messageInfo_Seed.DiscardUnknown(m)
}

var xxx_messageInfo_Seed proto.InternalMessageInfo

func (m *SeedBackup) Reset()      { *m = SeedBackup{} }
func (*SeedBackup) ProtoMessage() {}
func (*SeedBackup) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{101}
}
func (m *SeedBackup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedBackup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedBackup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedBackup.Merge(m, src)
}
func (m *SeedBackup) XXX_Size() int {
	return m.Size()
}
func (m *SeedBackup) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedBackup.DiscardUnknown(m)
}

var xxx_messageInfo_SeedBackup proto.InternalMessageInfo

func (m *SeedDNS) Reset()      { *m = SeedDNS{} }
func (*SeedDNS) ProtoMessage() {}
func (*SeedDNS) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{102}
}
func (m *SeedDNS) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedDNS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedDNS) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedDNS.Merge(m, src)
}
func (m *SeedDNS) XXX_Size() int {
	return m.Size()
}
func (m *SeedDNS) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedDNS.DiscardUnknown(m)
}

var xxx_messageInfo_SeedDNS proto.InternalMessageInfo

func (m *SeedDNSProvider) Reset()      { *m = SeedDNSProvider{} }
func (*SeedDNSProvider) ProtoMessage() {}
func (*SeedDNSProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{103}
}
func (m *SeedDNSProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedDNSProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedDNSProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedDNSProvider.Merge(m, src)
}
func (m *SeedDNSProvider) XXX_Size() int {
	return m.Size()
}
func (m *SeedDNSProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedDNSProvider.DiscardUnknown(m)
}

var xxx_messageInfo_SeedDNSProvider proto.InternalMessageInfo

func (m *SeedList) Reset()      { *m = SeedList{} }
func (*SeedList) ProtoMessage() {}
func (*SeedList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{104}
}
func (m *SeedList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedList.Merge(m, src)
}
func (m *SeedList) XXX_Size() int {
	return m.Size()
}
func (m *SeedList) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedList.DiscardUnknown(m)
}

var xxx_messageInfo_SeedList proto.InternalMessageInfo

func (m *SeedNetworks) Reset()      { *m = SeedNetworks{} }
func (*SeedNetworks) ProtoMessage() {}
func (*SeedNetworks) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{105}
}
func (m *SeedNetworks) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedNetworks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedNetworks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedNetworks.Merge(m, src)
}
func (m *SeedNetworks) XXX_Size() int {
	return m.Size()
}
func (m *SeedNetworks) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedNetworks.DiscardUnknown(m)
}

var xxx_messageInfo_SeedNetworks proto.InternalMessageInfo

func (m *SeedProvider) Reset()      { *m = SeedProvider{} }
func (*SeedProvider) ProtoMessage() {}
func (*SeedProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{106}
}
func (m *SeedProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedProvider.Merge(m, src)
}
func (m *SeedProvider) XXX_Size() int {
	return m.Size()
}
func (m *SeedProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedProvider.DiscardUnknown(m)
}

var xxx_messageInfo_SeedProvider proto.InternalMessageInfo

func (m *SeedSelector) Reset()      { *m = SeedSelector{} }
func (*SeedSelector) ProtoMessage() {}
func (*SeedSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{107}
}
func (m *SeedSelector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSelector.Merge(m, src)
}
func (m *SeedSelector) XXX_Size() int {
	return m.Size()
}
func (m *SeedSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSelector.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSelector proto.InternalMessageInfo

func (m *SeedSettingExcessCapacityReservation) Reset()      { *m = SeedSettingExcessCapacityReservation{} }
func (*SeedSettingExcessCapacityReservation) ProtoMessage() {}
func (*SeedSettingExcessCapacityReservation) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{108}
}
func (m *SeedSettingExcessCapacityReservation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettingExcessCapacityReservation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettingExcessCapacityReservation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettingExcessCapacityReservation.Merge(m, src)
}
func (m *SeedSettingExcessCapacityReservation) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettingExcessCapacityReservation) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettingExcessCapacityReservation.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettingExcessCapacityReservation proto.InternalMessageInfo

func (m *SeedSettingLoadBalancerServices) Reset()      { *m = SeedSettingLoadBalancerServices{} }
func (*SeedSettingLoadBalancerServices) ProtoMessage() {}
func (*SeedSettingLoadBalancerServices) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{109}
}
func (m *SeedSettingLoadBalancerServices) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettingLoadBalancerServices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettingLoadBalancerServices) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettingLoadBalancerServices.Merge(m, src)
}
func (m *SeedSettingLoadBalancerServices) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettingLoadBalancerServices) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettingLoadBalancerServices.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettingLoadBalancerServices proto.InternalMessageInfo

func (m *SeedSettingScheduling) Reset()      { *m = SeedSettingScheduling{} }
func (*SeedSettingScheduling) ProtoMessage() {}
func (*SeedSettingScheduling) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{110}
}
func (m *SeedSettingScheduling) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettingScheduling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettingScheduling) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettingScheduling.Merge(m, src)
}
func (m *SeedSettingScheduling) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettingScheduling) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettingScheduling.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettingScheduling proto.InternalMessageInfo

func (m *SeedSettingShootDNS) Reset()      { *m = SeedSettingShootDNS{} }
func (*SeedSettingShootDNS) ProtoMessage() {}
func (*SeedSettingShootDNS) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{111}
}
func (m *SeedSettingShootDNS) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettingShootDNS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettingShootDNS) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettingShootDNS.Merge(m, src)
}
func (m *SeedSettingShootDNS) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettingShootDNS) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettingShootDNS.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettingShootDNS proto.InternalMessageInfo

func (m *SeedSettingVerticalPodAutoscaler) Reset()      { *m = SeedSettingVerticalPodAutoscaler{} }
func (*SeedSettingVerticalPodAutoscaler) ProtoMessage() {}
func (*SeedSettingVerticalPodAutoscaler) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{112}
}
func (m *SeedSettingVerticalPodAutoscaler) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettingVerticalPodAutoscaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettingVerticalPodAutoscaler) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettingVerticalPodAutoscaler.Merge(m, src)
}
func (m *SeedSettingVerticalPodAutoscaler) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettingVerticalPodAutoscaler) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettingVerticalPodAutoscaler.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettingVerticalPodAutoscaler proto.InternalMessageInfo

func (m *SeedSettings) Reset()      { *m = SeedSettings{} }
func (*SeedSettings) ProtoMessage() {}
func (*SeedSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{113}
}
func (m *SeedSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSettings.Merge(m, src)
}
func (m *SeedSettings) XXX_Size() int {
	return m.Size()
}
func (m *SeedSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSettings.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSettings proto.InternalMessageInfo

func (m *SeedSpec) Reset()      { *m = SeedSpec{} }
func (*SeedSpec) ProtoMessage() {}
func (*SeedSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{114}
}
func (m *SeedSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedSpec.Merge(m, src)
}
func (m *SeedSpec) XXX_Size() int {
	return m.Size()
}
func (m *SeedSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedSpec.DiscardUnknown(m)
}

var xxx_messageInfo_SeedSpec proto.InternalMessageInfo

func (m *SeedStatus) Reset()      { *m = SeedStatus{} }
func (*SeedStatus) ProtoMessage() {}
func (*SeedStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{115}
}
func (m *SeedStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedStatus.Merge(m, src)
}
func (m *SeedStatus) XXX_Size() int {
	return m.Size()
}
func (m *SeedStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedStatus.DiscardUnknown(m)
}

var xxx_messageInfo_SeedStatus proto.InternalMessageInfo

func (m *SeedTaint) Reset()      { *m = SeedTaint{} }
func (*SeedTaint) ProtoMessage() {}
func (*SeedTaint) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{116}
}
func (m *SeedTaint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedTaint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedTaint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedTaint.Merge(m, src)
}
func (m *SeedTaint) XXX_Size() int {
	return m.Size()
}
func (m *SeedTaint) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedTaint.DiscardUnknown(m)
}

var xxx_messageInfo_SeedTaint proto.InternalMessageInfo

func (m *SeedVolume) Reset()      { *m = SeedVolume{} }
func (*SeedVolume) ProtoMessage() {}
func (*SeedVolume) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{117}
}
func (m *SeedVolume) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedVolume) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedVolume.Merge(m, src)
}
func (m *SeedVolume) XXX_Size() int {
	return m.Size()
}
func (m *SeedVolume) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedVolume.DiscardUnknown(m)
}

var xxx_messageInfo_SeedVolume proto.InternalMessageInfo

func (m *SeedVolumeProvider) Reset()      { *m = SeedVolumeProvider{} }
func (*SeedVolumeProvider) ProtoMessage() {}
func (*SeedVolumeProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{118}
}
func (m *SeedVolumeProvider) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SeedVolumeProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *SeedVolumeProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedVolumeProvider.Merge(m, src)
}
func (m *SeedVolumeProvider) XXX_Size() int {
	return m.Size()
}
func (m *SeedVolumeProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedVolumeProvider.DiscardUnknown(m)
}

var xxx_messageInfo_SeedVolumeProvider proto.InternalMessageInfo

func (m *ServiceAccountConfig) Reset()      { *m = ServiceAccountConfig{} }
func (*ServiceAccountConfig) ProtoMessage() {}
func (*ServiceAccountConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{119}
}
func (m *ServiceAccountConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ServiceAccountConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ServiceAccountConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceAccountConfig.Merge(m, src)
}
func (m *ServiceAccountConfig) XXX_Size() int {
	return m.Size()
}
func (m *ServiceAccountConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceAccountConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceAccountConfig proto.InternalMessageInfo

func (m *Shoot) Reset()      { *m = Shoot{} }
func (*Shoot) ProtoMessage() {}
func (*Shoot) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{120}
}
func (m *Shoot) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Shoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Shoot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Shoot.Merge(m, src)
}
func (m *Shoot) XXX_Size() int {
	return m.Size()
}
func (m *Shoot) XXX_DiscardUnknown() {
	xxx_messageInfo_Shoot.DiscardUnknown(m)
}

var xxx_messageInfo_Shoot proto.InternalMessageInfo

func (m *ShootList) Reset()      { *m = ShootList{} }
func (*ShootList) ProtoMessage() {}
func (*ShootList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{121}
}
func (m *ShootList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootList.Merge(m, src)
}
func (m *ShootList) XXX_Size() int {
	return m.Size()
}
func (m *ShootList) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootList.DiscardUnknown(m)
}

var xxx_messageInfo_ShootList proto.InternalMessageInfo

func (m *ShootMachineImage) Reset()      { *m = ShootMachineImage{} }
func (*ShootMachineImage) ProtoMessage() {}
func (*ShootMachineImage) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{122}
}
func (m *ShootMachineImage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootMachineImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootMachineImage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootMachineImage.Merge(m, src)
}
func (m *ShootMachineImage) XXX_Size() int {
	return m.Size()
}
func (m *ShootMachineImage) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootMachineImage.DiscardUnknown(m)
}

var xxx_messageInfo_ShootMachineImage proto.InternalMessageInfo

func (m *ShootNetworks) Reset()      { *m = ShootNetworks{} }
func (*ShootNetworks) ProtoMessage() {}
func (*ShootNetworks) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{123}
}
func (m *ShootNetworks) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootNetworks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootNetworks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootNetworks.Merge(m, src)
}
func (m *ShootNetworks) XXX_Size() int {
	return m.Size()
}
func (m *ShootNetworks) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootNetworks.DiscardUnknown(m)
}

var xxx_messageInfo_ShootNetworks proto.InternalMessageInfo

func (m *ShootSpec) Reset()      { *m = ShootSpec{} }
func (*ShootSpec) ProtoMessage() {}
func (*ShootSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{124}
}
func (m *ShootSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootSpec.Merge(m, src)
}
func (m *ShootSpec) XXX_Size() int {
	return m.Size()
}
func (m *ShootSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ShootSpec proto.InternalMessageInfo

func (m *ShootState) Reset()      { *m = ShootState{} }
func (*ShootState) ProtoMessage() {}
func (*ShootState) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{125}
}
func (m *ShootState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootState.Merge(m, src)
}
func (m *ShootState) XXX_Size() int {
	return m.Size()
}
func (m *ShootState) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootState.DiscardUnknown(m)
}

var xxx_messageInfo_ShootState proto.InternalMessageInfo

func (m *ShootStateList) Reset()      { *m = ShootStateList{} }
func (*ShootStateList) ProtoMessage() {}
func (*ShootStateList) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{126}
}
func (m *ShootStateList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootStateList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootStateList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootStateList.Merge(m, src)
}
func (m *ShootStateList) XXX_Size() int {
	return m.Size()
}
func (m *ShootStateList) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootStateList.DiscardUnknown(m)
}

var xxx_messageInfo_ShootStateList proto.InternalMessageInfo

func (m *ShootStateSpec) Reset()      { *m = ShootStateSpec{} }
func (*ShootStateSpec) ProtoMessage() {}
func (*ShootStateSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{127}
}
func (m *ShootStateSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootStateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootStateSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootStateSpec.Merge(m, src)
}
func (m *ShootStateSpec) XXX_Size() int {
	return m.Size()
}
func (m *ShootStateSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootStateSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ShootStateSpec proto.InternalMessageInfo

func (m *ShootStatus) Reset()      { *m = ShootStatus{} }
func (*ShootStatus) ProtoMessage() {}
func (*ShootStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{128}
}
func (m *ShootStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShootStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *ShootStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShootStatus.Merge(m, src)
}
func (m *ShootStatus) XXX_Size() int {
	return m.Size()
}
func (m *ShootStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ShootStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ShootStatus proto.InternalMessageInfo

func (m *Toleration) Reset()      { *m = Toleration{} }
func (*Toleration) ProtoMessage() {}
func (*Toleration) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{129}
}
func (m *Toleration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Toleration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Toleration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Toleration.Merge(m, src)
}
func (m *Toleration) XXX_Size() int {
	return m.Size()
}
func (m *Toleration) XXX_DiscardUnknown() {
	xxx_messageInfo_Toleration.DiscardUnknown(m)
}

var xxx_messageInfo_Toleration proto.InternalMessageInfo

func (m *VerticalPodAutoscaler) Reset()      { *m = VerticalPodAutoscaler{} }
func (*VerticalPodAutoscaler) ProtoMessage() {}
func (*VerticalPodAutoscaler) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{130}
}
func (m *VerticalPodAutoscaler) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VerticalPodAutoscaler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *VerticalPodAutoscaler) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerticalPodAutoscaler.Merge(m, src)
}
func (m *VerticalPodAutoscaler) XXX_Size() int {
	return m.Size()
}
func (m *VerticalPodAutoscaler) XXX_DiscardUnknown() {
	xxx_messageInfo_VerticalPodAutoscaler.DiscardUnknown(m)
}

var xxx_messageInfo_VerticalPodAutoscaler proto.InternalMessageInfo

func (m *Volume) Reset()      { *m = Volume{} }
func (*Volume) ProtoMessage() {}
func (*Volume) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{131}
}
func (m *Volume) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Volume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Volume) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Volume.Merge(m, src)
}
func (m *Volume) XXX_Size() int {
	return m.Size()
}
func (m *Volume) XXX_DiscardUnknown() {
	xxx_messageInfo_Volume.DiscardUnknown(m)
}

var xxx_messageInfo_Volume proto.InternalMessageInfo

func (m *VolumeType) Reset()      { *m = VolumeType{} }
func (*VolumeType) ProtoMessage() {}
func (*VolumeType) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{132}
}
func (m *VolumeType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VolumeType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *VolumeType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VolumeType.Merge(m, src)
}
func (m *VolumeType) XXX_Size() int {
	return m.Size()
}
func (m *VolumeType) XXX_DiscardUnknown() {
	xxx_messageInfo_VolumeType.DiscardUnknown(m)
}

var xxx_messageInfo_VolumeType proto.InternalMessageInfo

func (m *WatchCacheSizes) Reset()      { *m = WatchCacheSizes{} }
func (*WatchCacheSizes) ProtoMessage() {}
func (*WatchCacheSizes) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{133}
}
func (m *WatchCacheSizes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WatchCacheSizes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WatchCacheSizes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchCacheSizes.Merge(m, src)
}
func (m *WatchCacheSizes) XXX_Size() int {
	return m.Size()
}
func (m *WatchCacheSizes) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchCacheSizes.DiscardUnknown(m)
}

var xxx_messageInfo_WatchCacheSizes proto.InternalMessageInfo

func (m *Worker) Reset()      { *m = Worker{} }
func (*Worker) ProtoMessage() {}
func (*Worker) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{134}
}
func (m *Worker) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Worker) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Worker) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Worker.Merge(m, src)
}
func (m *Worker) XXX_Size() int {
	return m.Size()
}
func (m *Worker) XXX_DiscardUnknown() {
	xxx_messageInfo_Worker.DiscardUnknown(m)
}

var xxx_messageInfo_Worker proto.InternalMessageInfo

func (m *WorkerKubernetes) Reset()      { *m = WorkerKubernetes{} }
func (*WorkerKubernetes) ProtoMessage() {}
func (*WorkerKubernetes) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{135}
}
func (m *WorkerKubernetes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkerKubernetes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WorkerKubernetes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkerKubernetes.Merge(m, src)
}
func (m *WorkerKubernetes) XXX_Size() int {
	return m.Size()
}
func (m *WorkerKubernetes) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkerKubernetes.DiscardUnknown(m)
}

var xxx_messageInfo_WorkerKubernetes proto.InternalMessageInfo

func (m *WorkerSystemComponents) Reset()      { *m = WorkerSystemComponents{} }
func (*WorkerSystemComponents) ProtoMessage() {}
func (*WorkerSystemComponents) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1caaec5647a9dbf, []int{136}
}
func (m *WorkerSystemComponents) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WorkerSystemComponents) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *WorkerSystemComponents) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkerSystemComponents.Merge(m, src)
}
func (m *WorkerSystemComponents) XXX_Size() int {
	return m.Size()
}
func (m *WorkerSystemComponents) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkerSystemComponents.DiscardUnknown(m)
}

var xxx_messageInfo_WorkerSystemComponents proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Addon)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Addon")
	proto.RegisterType((*Addons)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Addons")
	proto.RegisterType((*AdmissionPlugin)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.AdmissionPlugin")
	proto.RegisterType((*Alerting)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Alerting")
	proto.RegisterType((*AuditConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.AuditConfig")
	proto.RegisterType((*AuditPolicy)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.AuditPolicy")
	proto.RegisterType((*AvailabilityZone)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.AvailabilityZone")
	proto.RegisterType((*BackupBucket)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupBucket")
	proto.RegisterType((*BackupBucketList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupBucketList")
	proto.RegisterType((*BackupBucketProvider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupBucketProvider")
	proto.RegisterType((*BackupBucketSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupBucketSpec")
	proto.RegisterType((*BackupBucketStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupBucketStatus")
	proto.RegisterType((*BackupEntry)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupEntry")
	proto.RegisterType((*BackupEntryList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupEntryList")
	proto.RegisterType((*BackupEntrySpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupEntrySpec")
	proto.RegisterType((*BackupEntryStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.BackupEntryStatus")
	proto.RegisterType((*CRI)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.CRI")
	proto.RegisterType((*CloudInfo)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.CloudInfo")
	proto.RegisterType((*CloudProfile)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.CloudProfile")
	proto.RegisterType((*CloudProfileList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.CloudProfileList")
	proto.RegisterType((*CloudProfileSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.CloudProfileSpec")
	proto.RegisterType((*ClusterAutoscaler)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ClusterAutoscaler")
	proto.RegisterType((*ClusterInfo)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ClusterInfo")
	proto.RegisterType((*Condition)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Condition")
	proto.RegisterType((*ContainerRuntime)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ContainerRuntime")
	proto.RegisterType((*ControllerDeployment)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerDeployment")
	proto.RegisterType((*ControllerInstallation)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerInstallation")
	proto.RegisterType((*ControllerInstallationList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerInstallationList")
	proto.RegisterType((*ControllerInstallationSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerInstallationSpec")
	proto.RegisterType((*ControllerInstallationStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerInstallationStatus")
	proto.RegisterType((*ControllerRegistration)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerRegistration")
	proto.RegisterType((*ControllerRegistrationList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerRegistrationList")
	proto.RegisterType((*ControllerRegistrationSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerRegistrationSpec")
	proto.RegisterType((*ControllerResource)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ControllerResource")
	proto.RegisterType((*DNS)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.DNS")
	proto.RegisterType((*DNSIncludeExclude)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.DNSIncludeExclude")
	proto.RegisterType((*DNSProvider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.DNSProvider")
	proto.RegisterType((*DataVolume)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.DataVolume")
	proto.RegisterType((*Endpoint)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Endpoint")
	proto.RegisterType((*ExpirableVersion)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ExpirableVersion")
	proto.RegisterType((*Extension)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Extension")
	proto.RegisterType((*ExtensionResourceState)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ExtensionResourceState")
	proto.RegisterType((*Gardener)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Gardener")
	proto.RegisterType((*GardenerResourceData)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.GardenerResourceData")
	proto.RegisterType((*Hibernation)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Hibernation")
	proto.RegisterType((*HibernationSchedule)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.HibernationSchedule")
	proto.RegisterType((*HorizontalPodAutoscalerConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.HorizontalPodAutoscalerConfig")
	proto.RegisterType((*Ingress)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Ingress")
	proto.RegisterType((*IngressController)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.IngressController")
	proto.RegisterType((*KubeAPIServerConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeAPIServerConfig")
	proto.RegisterMapType((map[string]bool)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeAPIServerConfig.RuntimeConfigEntry")
	proto.RegisterType((*KubeAPIServerRequests)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeAPIServerRequests")
	proto.RegisterType((*KubeControllerManagerConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeControllerManagerConfig")
	proto.RegisterType((*KubeProxyConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeProxyConfig")
	proto.RegisterType((*KubeSchedulerConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeSchedulerConfig")
	proto.RegisterType((*KubeletConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeletConfig")
	proto.RegisterType((*KubeletConfigEviction)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeletConfigEviction")
	proto.RegisterType((*KubeletConfigEvictionMinimumReclaim)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeletConfigEvictionMinimumReclaim")
	proto.RegisterType((*KubeletConfigEvictionSoftGracePeriod)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeletConfigEvictionSoftGracePeriod")
	proto.RegisterType((*KubeletConfigReserved)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubeletConfigReserved")
	proto.RegisterType((*Kubernetes)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Kubernetes")
	proto.RegisterType((*KubernetesConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubernetesConfig")
	proto.RegisterMapType((map[string]bool)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubernetesConfig.FeatureGatesEntry")
	proto.RegisterType((*KubernetesDashboard)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubernetesDashboard")
	proto.RegisterType((*KubernetesInfo)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubernetesInfo")
	proto.RegisterType((*KubernetesSettings)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.KubernetesSettings")
	proto.RegisterType((*LastError)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.LastError")
	proto.RegisterType((*LastOperation)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.LastOperation")
	proto.RegisterType((*Machine)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Machine")
	proto.RegisterType((*MachineControllerManagerSettings)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MachineControllerManagerSettings")
	proto.RegisterType((*MachineImage)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MachineImage")
	proto.RegisterType((*MachineImageVersion)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MachineImageVersion")
	proto.RegisterType((*MachineType)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MachineType")
	proto.RegisterType((*MachineTypeStorage)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MachineTypeStorage")
	proto.RegisterType((*Maintenance)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Maintenance")
	proto.RegisterType((*MaintenanceAutoUpdate)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MaintenanceAutoUpdate")
	proto.RegisterType((*MaintenanceTimeWindow)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.MaintenanceTimeWindow")
	proto.RegisterType((*Monitoring)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Monitoring")
	proto.RegisterType((*NamedResourceReference)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.NamedResourceReference")
	proto.RegisterType((*Networking)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Networking")
	proto.RegisterType((*NginxIngress)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.NginxIngress")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.NginxIngress.ConfigEntry")
	proto.RegisterType((*OIDCConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.OIDCConfig")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.OIDCConfig.RequiredClaimsEntry")
	proto.RegisterType((*OpenIDConnectClientAuthentication)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.OpenIDConnectClientAuthentication")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.OpenIDConnectClientAuthentication.ExtraConfigEntry")
	proto.RegisterType((*Plant)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Plant")
	proto.RegisterType((*PlantList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.PlantList")
	proto.RegisterType((*PlantSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.PlantSpec")
	proto.RegisterType((*PlantStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.PlantStatus")
	proto.RegisterType((*Project)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Project")
	proto.RegisterType((*ProjectList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ProjectList")
	proto.RegisterType((*ProjectMember)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ProjectMember")
	proto.RegisterType((*ProjectSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ProjectSpec")
	proto.RegisterType((*ProjectStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ProjectStatus")
	proto.RegisterType((*ProjectTolerations)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ProjectTolerations")
	proto.RegisterType((*Provider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Provider")
	proto.RegisterType((*Quota)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Quota")
	proto.RegisterType((*QuotaList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.QuotaList")
	proto.RegisterType((*QuotaSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.QuotaSpec")
	proto.RegisterMapType((k8s_io_api_core_v1.ResourceList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.QuotaSpec.MetricsEntry")
	proto.RegisterType((*Region)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Region")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Region.LabelsEntry")
	proto.RegisterType((*ResourceData)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ResourceData")
	proto.RegisterType((*ResourceWatchCacheSize)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ResourceWatchCacheSize")
	proto.RegisterType((*SecretBinding)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SecretBinding")
	proto.RegisterType((*SecretBindingList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SecretBindingList")
	proto.RegisterType((*Seed)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Seed")
	proto.RegisterType((*SeedBackup)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedBackup")
	proto.RegisterType((*SeedDNS)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedDNS")
	proto.RegisterType((*SeedDNSProvider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedDNSProvider")
	proto.RegisterType((*SeedList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedList")
	proto.RegisterType((*SeedNetworks)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedNetworks")
	proto.RegisterType((*SeedProvider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedProvider")
	proto.RegisterType((*SeedSelector)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSelector")
	proto.RegisterType((*SeedSettingExcessCapacityReservation)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingExcessCapacityReservation")
	proto.RegisterType((*SeedSettingLoadBalancerServices)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingLoadBalancerServices")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingLoadBalancerServices.AnnotationsEntry")
	proto.RegisterType((*SeedSettingScheduling)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingScheduling")
	proto.RegisterType((*SeedSettingShootDNS)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingShootDNS")
	proto.RegisterType((*SeedSettingVerticalPodAutoscaler)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettingVerticalPodAutoscaler")
	proto.RegisterType((*SeedSettings)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSettings")
	proto.RegisterType((*SeedSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedSpec")
	proto.RegisterType((*SeedStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedStatus")
	proto.RegisterType((*SeedTaint)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedTaint")
	proto.RegisterType((*SeedVolume)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedVolume")
	proto.RegisterType((*SeedVolumeProvider)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.SeedVolumeProvider")
	proto.RegisterType((*ServiceAccountConfig)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ServiceAccountConfig")
	proto.RegisterType((*Shoot)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Shoot")
	proto.RegisterType((*ShootList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootList")
	proto.RegisterType((*ShootMachineImage)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootMachineImage")
	proto.RegisterType((*ShootNetworks)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootNetworks")
	proto.RegisterType((*ShootSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootSpec")
	proto.RegisterType((*ShootState)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootState")
	proto.RegisterType((*ShootStateList)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootStateList")
	proto.RegisterType((*ShootStateSpec)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootStateSpec")
	proto.RegisterType((*ShootStatus)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.ShootStatus")
	proto.RegisterType((*Toleration)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Toleration")
	proto.RegisterType((*VerticalPodAutoscaler)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.VerticalPodAutoscaler")
	proto.RegisterType((*Volume)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Volume")
	proto.RegisterType((*VolumeType)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.VolumeType")
	proto.RegisterType((*WatchCacheSizes)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.WatchCacheSizes")
	proto.RegisterType((*Worker)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Worker")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Worker.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.Worker.LabelsEntry")
	proto.RegisterType((*WorkerKubernetes)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.WorkerKubernetes")
	proto.RegisterType((*WorkerSystemComponents)(nil), "github.com.gardener.gardener.pkg.apis.core.v1alpha1.WorkerSystemComponents")
}

func init() {
	proto.RegisterFile("github.com/gardener/gardener/pkg/apis/core/v1alpha1/generated.proto", fileDescriptor_f1caaec5647a9dbf)
}

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

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

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

func (m *Addon) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AdmissionPlugin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Alerting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EmailReceivers) > 0 {
		for iNdEx := len(m.EmailReceivers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.EmailReceivers[iNdEx])
			copy(dAtA[i:], m.EmailReceivers[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.EmailReceivers[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *AvailabilityZone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UnavailableVolumeTypes) > 0 {
		for iNdEx := len(m.UnavailableVolumeTypes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnavailableVolumeTypes[iNdEx])
			copy(dAtA[i:], m.UnavailableVolumeTypes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.UnavailableVolumeTypes[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.UnavailableMachineTypes) > 0 {
		for iNdEx := len(m.UnavailableMachineTypes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnavailableMachineTypes[iNdEx])
			copy(dAtA[i:], m.UnavailableMachineTypes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.UnavailableMachineTypes[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *BackupBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *BackupBucketSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Seed != nil {
		i -= len(*m.Seed)
		copy(dAtA[i:], *m.Seed)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Seed)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *BackupBucketStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GeneratedSecretRef != nil {
		{
			size, err := m.GeneratedSecretRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
	i--
	dAtA[i] = 0x20
	if m.LastError != nil {
		{
			size, err := m.LastError.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.LastOperation != nil {
		{
			size, err := m.LastOperation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ProviderStatus != nil {
		{
			size, err := m.ProviderStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *BackupEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *BackupEntrySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Seed != nil {
		i -= len(*m.Seed)
		copy(dAtA[i:], *m.Seed)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Seed)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.BucketName)
	copy(dAtA[i:], m.BucketName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.BucketName)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *BackupEntryStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
	i--
	dAtA[i] = 0x18
	if m.LastError != nil {
		{
			size, err := m.LastError.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.LastOperation != nil {
		{
			size, err := m.LastOperation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *CloudProfileSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VolumeTypes) > 0 {
		for iNdEx := len(m.VolumeTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VolumeTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0x42
	if m.SeedSelector != nil {
		{
			size, err := m.SeedSelector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Regions) > 0 {
		for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.MachineTypes) > 0 {
		for iNdEx := len(m.MachineTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MachineTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.MachineImages) > 0 {
		for iNdEx := len(m.MachineImages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MachineImages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.Kubernetes.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.CABundle != nil {
		i -= len(*m.CABundle)
		copy(dAtA[i:], *m.CABundle)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.CABundle)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ClusterAutoscaler) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ScanInterval != nil {
		{
			size, err := m.ScanInterval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ScaleDownUtilizationThreshold != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.ScaleDownUtilizationThreshold))))
		i--
		dAtA[i] = 0x29
	}
	if m.ScaleDownUnneededTime != nil {
		{
			size, err := m.ScaleDownUnneededTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ScaleDownDelayAfterFailure != nil {
		{
			size, err := m.ScaleDownDelayAfterFailure.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ScaleDownDelayAfterDelete != nil {
		{
			size, err := m.ScaleDownDelayAfterDelete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ScaleDownDelayAfterAdd != nil {
		{
			size, err := m.ScaleDownDelayAfterAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *Condition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Codes) > 0 {
		for iNdEx := len(m.Codes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Codes[iNdEx])
			copy(dAtA[i:], m.Codes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Codes[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	i -= len(m.Message)
	copy(dAtA[i:], m.Message)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
	i--
	dAtA[i] = 0x32
	i -= len(m.Reason)
	copy(dAtA[i:], m.Reason)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	i -= len(m.Status)
	copy(dAtA[i:], m.Status)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ContainerRuntime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ControllerDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SeedSelector != nil {
		{
			size, err := m.SeedSelector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Policy != nil {
		i -= len(*m.Policy)
		copy(dAtA[i:], *m.Policy)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Policy)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ControllerInstallation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *ControllerResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Primary != nil {
		i--
		if *m.Primary {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.ReconcileTimeout != nil {
		{
			size, err := m.ReconcileTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.GloballyEnabled != nil {
		i--
		if *m.GloballyEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Kind)
	copy(dAtA[i:], m.Kind)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *DNSIncludeExclude) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Exclude) > 0 {
		for iNdEx := len(m.Exclude) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Exclude[iNdEx])
			copy(dAtA[i:], m.Exclude[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Exclude[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Include) > 0 {
		for iNdEx := len(m.Include) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Include[iNdEx])
			copy(dAtA[i:], m.Include[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Include[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DNSProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Zones != nil {
		{
			size, err := m.Zones.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Type != nil {
		i -= len(*m.Type)
		copy(dAtA[i:], *m.Type)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Type)))
		i--
		dAtA[i] = 0x22
	}
	if m.SecretName != nil {
		i -= len(*m.SecretName)
		copy(dAtA[i:], *m.SecretName)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SecretName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Primary != nil {
		i--
		if *m.Primary {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Domains != nil {
		{
			size, err := m.Domains.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DataVolume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Encrypted != nil {
		i--
		if *m.Encrypted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	i -= len(m.VolumeSize)
	copy(dAtA[i:], m.VolumeSize)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.VolumeSize)))
	i--
	dAtA[i] = 0x1a
	if m.Type != nil {
		i -= len(*m.Type)
		copy(dAtA[i:], *m.Type)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Type)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Endpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Purpose)
	copy(dAtA[i:], m.Purpose)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Purpose)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.URL)
	copy(dAtA[i:], m.URL)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ExpirableVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Classification != nil {
		i -= len(*m.Classification)
		copy(dAtA[i:], *m.Classification)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Classification)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ExpirationDate != nil {
		{
			size, err := m.ExpirationDate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Version)
	copy(dAtA[i:], m.Version)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Extension) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Disabled != nil {
		i--
		if *m.Disabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ExtensionResourceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Resources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Purpose != nil {
		i -= len(*m.Purpose)
		copy(dAtA[i:], *m.Purpose)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Purpose)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Name != nil {
		i -= len(*m.Name)
		copy(dAtA[i:], *m.Name)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Name)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Kind)
	copy(dAtA[i:], m.Kind)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Gardener) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Version)
	copy(dAtA[i:], m.Version)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x12
	i -= len(m.ID)
	copy(dAtA[i:], m.ID)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ID)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *GardenerResourceData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Hibernation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Schedules) > 0 {
		for iNdEx := len(m.Schedules) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Schedules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Enabled != nil {
		i--
		if *m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HibernationSchedule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Location != nil {
		i -= len(*m.Location)
		copy(dAtA[i:], *m.Location)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Location)))
		i--
		dAtA[i] = 0x1a
	}
	if m.End != nil {
		i -= len(*m.End)
		copy(dAtA[i:], *m.End)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.End)))
		i--
		dAtA[i] = 0x12
	}
	if m.Start != nil {
		i -= len(*m.Start)
		copy(dAtA[i:], *m.Start)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Start)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HorizontalPodAutoscalerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpscaleDelay != nil {
		{
			size, err := m.UpscaleDelay.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Tolerance != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Tolerance))))
		i--
		dAtA[i] = 0x31
	}
	if m.SyncPeriod != nil {
		{
			size, err := m.SyncPeriod.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.InitialReadinessDelay != nil {
		{
			size, err := m.InitialReadinessDelay.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.DownscaleStabilization != nil {
		{
			size, err := m.DownscaleStabilization.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.DownscaleDelay != nil {
		{
			size, err := m.DownscaleDelay.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.CPUInitializationPeriod != nil {
		{
			size, err := m.CPUInitializationPeriod.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Ingress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Controller.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Domain)
	copy(dAtA[i:], m.Domain)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Domain)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *IngressController) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Kind)
	copy(dAtA[i:], m.Kind)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeAPIServerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Requests != nil {
		{
			size, err := m.Requests.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.WatchCacheSizes != nil {
		{
			size, err := m.WatchCacheSizes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.ServiceAccountConfig != nil {
		{
			size, err := m.ServiceAccountConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.RuntimeConfig) > 0 {
		keysForRuntimeConfig := make([]string, 0, len(m.RuntimeConfig))
		for k := range m.RuntimeConfig {
			keysForRuntimeConfig = append(keysForRuntimeConfig, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForRuntimeConfig)
		for iNdEx := len(keysForRuntimeConfig) - 1; iNdEx >= 0; iNdEx-- {
			v := m.RuntimeConfig[string(keysForRuntimeConfig[iNdEx])]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i -= len(keysForRuntimeConfig[iNdEx])
			copy(dAtA[i:], keysForRuntimeConfig[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForRuntimeConfig[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.OIDCConfig != nil {
		{
			size, err := m.OIDCConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.EnableBasicAuthentication != nil {
		i--
		if *m.EnableBasicAuthentication {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.AuditConfig != nil {
		{
			size, err := m.AuditConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.APIAudiences) > 0 {
		for iNdEx := len(m.APIAudiences) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.APIAudiences[iNdEx])
			copy(dAtA[i:], m.APIAudiences[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIAudiences[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.AdmissionPlugins) > 0 {
		for iNdEx := len(m.AdmissionPlugins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AdmissionPlugins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.KubernetesConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeAPIServerRequests) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxMutatingInflight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxMutatingInflight))
		i--
		dAtA[i] = 0x10
	}
	if m.MaxNonMutatingInflight != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxNonMutatingInflight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubeControllerManagerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PodEvictionTimeout != nil {
		{
			size, err := m.PodEvictionTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.NodeCIDRMaskSize != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.NodeCIDRMaskSize))
		i--
		dAtA[i] = 0x18
	}
	if m.HorizontalPodAutoscalerConfig != nil {
		{
			size, err := m.HorizontalPodAutoscalerConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.KubernetesConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeProxyConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != nil {
		i -= len(*m.Mode)
		copy(dAtA[i:], *m.Mode)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Mode)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.KubernetesConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeSchedulerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KubeMaxPDVols != nil {
		i -= len(*m.KubeMaxPDVols)
		copy(dAtA[i:], *m.KubeMaxPDVols)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.KubeMaxPDVols)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.KubernetesConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeletConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SystemReserved != nil {
		{
			size, err := m.SystemReserved.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.KubeReserved != nil {
		{
			size, err := m.KubeReserved.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.FailSwapOn != nil {
		i--
		if *m.FailSwapOn {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.ImagePullProgressDeadline != nil {
		{
			size, err := m.ImagePullProgressDeadline.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.PodPIDsLimit != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.PodPIDsLimit))
		i--
		dAtA[i] = 0x58
	}
	if m.MaxPods != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxPods))
		i--
		dAtA[i] = 0x50
	}
	if m.EvictionSoftGracePeriod != nil {
		{
			size, err := m.EvictionSoftGracePeriod.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.EvictionSoft != nil {
		{
			size, err := m.EvictionSoft.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.EvictionPressureTransitionPeriod != nil {
		{
			size, err := m.EvictionPressureTransitionPeriod.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.EvictionMinimumReclaim != nil {
		{
			size, err := m.EvictionMinimumReclaim.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.EvictionMaxPodGracePeriod != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.EvictionMaxPodGracePeriod))
		i--
		dAtA[i] = 0x28
	}
	if m.EvictionHard != nil {
		{
			size, err := m.EvictionHard.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.CPUManagerPolicy != nil {
		i -= len(*m.CPUManagerPolicy)
		copy(dAtA[i:], *m.CPUManagerPolicy)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.CPUManagerPolicy)))
		i--
		dAtA[i] = 0x1a
	}
	if m.CPUCFSQuota != nil {
		i--
		if *m.CPUCFSQuota {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.KubernetesConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *KubeletConfigEviction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NodeFSInodesFree != nil {
		i -= len(*m.NodeFSInodesFree)
		copy(dAtA[i:], *m.NodeFSInodesFree)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.NodeFSInodesFree)))
		i--
		dAtA[i] = 0x2a
	}
	if m.NodeFSAvailable != nil {
		i -= len(*m.NodeFSAvailable)
		copy(dAtA[i:], *m.NodeFSAvailable)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.NodeFSAvailable)))
		i--
		dAtA[i] = 0x22
	}
	if m.ImageFSInodesFree != nil {
		i -= len(*m.ImageFSInodesFree)
		copy(dAtA[i:], *m.ImageFSInodesFree)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ImageFSInodesFree)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ImageFSAvailable != nil {
		i -= len(*m.ImageFSAvailable)
		copy(dAtA[i:], *m.ImageFSAvailable)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ImageFSAvailable)))
		i--
		dAtA[i] = 0x12
	}
	if m.MemoryAvailable != nil {
		i -= len(*m.MemoryAvailable)
		copy(dAtA[i:], *m.MemoryAvailable)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MemoryAvailable)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubeletConfigEvictionMinimumReclaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NodeFSInodesFree != nil {
		{
			size, err := m.NodeFSInodesFree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.NodeFSAvailable != nil {
		{
			size, err := m.NodeFSAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ImageFSInodesFree != nil {
		{
			size, err := m.ImageFSInodesFree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ImageFSAvailable != nil {
		{
			size, err := m.ImageFSAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MemoryAvailable != nil {
		{
			size, err := m.MemoryAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubeletConfigEvictionSoftGracePeriod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NodeFSInodesFree != nil {
		{
			size, err := m.NodeFSInodesFree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.NodeFSAvailable != nil {
		{
			size, err := m.NodeFSAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ImageFSInodesFree != nil {
		{
			size, err := m.ImageFSInodesFree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ImageFSAvailable != nil {
		{
			size, err := m.ImageFSAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MemoryAvailable != nil {
		{
			size, err := m.MemoryAvailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubeletConfigReserved) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PID != nil {
		{
			size, err := m.PID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.EphemeralStorage != nil {
		{
			size, err := m.EphemeralStorage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Memory != nil {
		{
			size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.CPU != nil {
		{
			size, err := m.CPU.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Kubernetes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VerticalPodAutoscaler != nil {
		{
			size, err := m.VerticalPodAutoscaler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	i -= len(m.Version)
	copy(dAtA[i:], m.Version)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
	i--
	dAtA[i] = 0x42
	if m.Kubelet != nil {
		{
			size, err := m.Kubelet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.KubeProxy != nil {
		{
			size, err := m.KubeProxy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.KubeScheduler != nil {
		{
			size, err := m.KubeScheduler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.KubeControllerManager != nil {
		{
			size, err := m.KubeControllerManager.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.KubeAPIServer != nil {
		{
			size, err := m.KubeAPIServer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ClusterAutoscaler != nil {
		{
			size, err := m.ClusterAutoscaler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.AllowPrivilegedContainers != nil {
		i--
		if *m.AllowPrivilegedContainers {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubernetesConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FeatureGates) > 0 {
		keysForFeatureGates := make([]string, 0, len(m.FeatureGates))
		for k := range m.FeatureGates {
			keysForFeatureGates = append(keysForFeatureGates, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForFeatureGates)
		for iNdEx := len(keysForFeatureGates) - 1; iNdEx >= 0; iNdEx-- {
			v := m.FeatureGates[string(keysForFeatureGates[iNdEx])]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i -= len(keysForFeatureGates[iNdEx])
			copy(dAtA[i:], keysForFeatureGates[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForFeatureGates[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubernetesDashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Addon.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.AuthenticationMode != nil {
		i -= len(*m.AuthenticationMode)
		copy(dAtA[i:], *m.AuthenticationMode)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.AuthenticationMode)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *KubernetesInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Version)
	copy(dAtA[i:], m.Version)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *LastError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastUpdateTime != nil {
		{
			size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Codes) > 0 {
		for iNdEx := len(m.Codes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Codes[iNdEx])
			copy(dAtA[i:], m.Codes[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Codes[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TaskID != nil {
		i -= len(*m.TaskID)
		copy(dAtA[i:], *m.TaskID)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.TaskID)))
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Description)
	copy(dAtA[i:], m.Description)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *LastOperation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0x2a
	i -= len(m.State)
	copy(dAtA[i:], m.State)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.State)))
	i--
	dAtA[i] = 0x22
	i = encodeVarintGenerated(dAtA, i, uint64(m.Progress))
	i--
	dAtA[i] = 0x18
	{
		size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Description)
	copy(dAtA[i:], m.Description)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Machine) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Image != nil {
		{
			size, err := m.Image.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *MachineControllerManagerSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NodeConditions) > 0 {
		for iNdEx := len(m.NodeConditions) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.NodeConditions[iNdEx])
			copy(dAtA[i:], m.NodeConditions[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeConditions[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.MaxEvictRetries != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxEvictRetries))
		i--
		dAtA[i] = 0x20
	}
	if m.MachineCreationTimeout != nil {
		{
			size, err := m.MachineCreationTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.MachineHealthTimeout != nil {
		{
			size, err := m.MachineHealthTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MachineDrainTimeout != nil {
		{
			size, err := m.MachineDrainTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *MachineType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Usable != nil {
		i--
		if *m.Usable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Storage != nil {
		{
			size, err := m.Storage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x22
	{
		size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.GPU.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.CPU.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *MachineTypeStorage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.StorageSize.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Class)
	copy(dAtA[i:], m.Class)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Class)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Maintenance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConfineSpecUpdateRollout != nil {
		i--
		if *m.ConfineSpecUpdateRollout {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.TimeWindow != nil {
		{
			size, err := m.TimeWindow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.AutoUpdate != nil {
		{
			size, err := m.AutoUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *MaintenanceAutoUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.MachineImageVersion {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x10
	i--
	if m.KubernetesVersion {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *MaintenanceTimeWindow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.End)
	copy(dAtA[i:], m.End)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.End)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Begin)
	copy(dAtA[i:], m.Begin)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Begin)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *NamedResourceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ResourceRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *Networking) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Services != nil {
		i -= len(*m.Services)
		copy(dAtA[i:], *m.Services)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Services)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Nodes != nil {
		i -= len(*m.Nodes)
		copy(dAtA[i:], *m.Nodes)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Nodes)))
		i--
		dAtA[i] = 0x22
	}
	if m.Pods != nil {
		i -= len(*m.Pods)
		copy(dAtA[i:], *m.Pods)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Pods)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *NginxIngress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Addon.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.ExternalTrafficPolicy != nil {
		i -= len(*m.ExternalTrafficPolicy)
		copy(dAtA[i:], *m.ExternalTrafficPolicy)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ExternalTrafficPolicy)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Config) > 0 {
		keysForConfig := make([]string, 0, len(m.Config))
		for k := range m.Config {
			keysForConfig = append(keysForConfig, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForConfig)
		for iNdEx := len(keysForConfig) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Config[string(keysForConfig[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForConfig[iNdEx])
			copy(dAtA[i:], keysForConfig[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForConfig[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.LoadBalancerSourceRanges) > 0 {
		for iNdEx := len(m.LoadBalancerSourceRanges) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.LoadBalancerSourceRanges[iNdEx])
			copy(dAtA[i:], m.LoadBalancerSourceRanges[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.LoadBalancerSourceRanges[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OIDCConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UsernamePrefix != nil {
		i -= len(*m.UsernamePrefix)
		copy(dAtA[i:], *m.UsernamePrefix)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UsernamePrefix)))
		i--
		dAtA[i] = 0x52
	}
	if m.UsernameClaim != nil {
		i -= len(*m.UsernameClaim)
		copy(dAtA[i:], *m.UsernameClaim)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UsernameClaim)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.SigningAlgs) > 0 {
		for iNdEx := len(m.SigningAlgs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SigningAlgs[iNdEx])
			copy(dAtA[i:], m.SigningAlgs[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.SigningAlgs[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.RequiredClaims) > 0 {
		keysForRequiredClaims := make([]string, 0, len(m.RequiredClaims))
		for k := range m.RequiredClaims {
			keysForRequiredClaims = append(keysForRequiredClaims, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForRequiredClaims)
		for iNdEx := len(keysForRequiredClaims) - 1; iNdEx >= 0; iNdEx-- {
			v := m.RequiredClaims[string(keysForRequiredClaims[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForRequiredClaims[iNdEx])
			copy(dAtA[i:], keysForRequiredClaims[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForRequiredClaims[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.IssuerURL != nil {
		i -= len(*m.IssuerURL)
		copy(dAtA[i:], *m.IssuerURL)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.IssuerURL)))
		i--
		dAtA[i] = 0x32
	}
	if m.GroupsPrefix != nil {
		i -= len(*m.GroupsPrefix)
		copy(dAtA[i:], *m.GroupsPrefix)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.GroupsPrefix)))
		i--
		dAtA[i] = 0x2a
	}
	if m.GroupsClaim != nil {
		i -= len(*m.GroupsClaim)
		copy(dAtA[i:], *m.GroupsClaim)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.GroupsClaim)))
		i--
		dAtA[i] = 0x22
	}
	if m.ClientID != nil {
		i -= len(*m.ClientID)
		copy(dAtA[i:], *m.ClientID)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ClientID)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ClientAuthentication != nil {
		{
			size, err := m.ClientAuthentication.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.CABundle != nil {
		i -= len(*m.CABundle)
		copy(dAtA[i:], *m.CABundle)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.CABundle)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OpenIDConnectClientAuthentication) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Secret != nil {
		i -= len(*m.Secret)
		copy(dAtA[i:], *m.Secret)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Secret)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ExtraConfig) > 0 {
		keysForExtraConfig := make([]string, 0, len(m.ExtraConfig))
		for k := range m.ExtraConfig {
			keysForExtraConfig = append(keysForExtraConfig, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForExtraConfig)
		for iNdEx := len(keysForExtraConfig) - 1; iNdEx >= 0; iNdEx-- {
			v := m.ExtraConfig[string(keysForExtraConfig[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForExtraConfig[iNdEx])
			copy(dAtA[i:], keysForExtraConfig[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForExtraConfig[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Plant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *Project) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *ProjectSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Tolerations != nil {
		{
			size, err := m.Tolerations.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Namespace != nil {
		i -= len(*m.Namespace)
		copy(dAtA[i:], *m.Namespace)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Namespace)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Members) > 0 {
		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Purpose != nil {
		i -= len(*m.Purpose)
		copy(dAtA[i:], *m.Purpose)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Purpose)))
		i--
		dAtA[i] = 0x22
	}
	if m.Owner != nil {
		{
			size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Description != nil {
		i -= len(*m.Description)
		copy(dAtA[i:], *m.Description)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.CreatedBy != nil {
		{
			size, err := m.CreatedBy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProjectStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StaleAutoDeleteTimestamp != nil {
		{
			size, err := m.StaleAutoDeleteTimestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.StaleSinceTimestamp != nil {
		{
			size, err := m.StaleSinceTimestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	i -= len(m.Phase)
	copy(dAtA[i:], m.Phase)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
	i--
	dAtA[i] = 0x12
	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QuotaSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Scope.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Metrics) > 0 {
		keysForMetrics := make([]string, 0, len(m.Metrics))
		for k := range m.Metrics {
			keysForMetrics = append(keysForMetrics, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForMetrics)
		for iNdEx := len(keysForMetrics) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Metrics[k8s_io_api_core_v1.ResourceName(keysForMetrics[iNdEx])]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(keysForMetrics[iNdEx])
			copy(dAtA[i:], keysForMetrics[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForMetrics[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ClusterLifetimeDays != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.ClusterLifetimeDays))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Region) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Labels) > 0 {
		keysForLabels := make([]string, 0, len(m.Labels))
		for k := range m.Labels {
			keysForLabels = append(keysForLabels, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Labels[string(keysForLabels[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForLabels[iNdEx])
			copy(dAtA[i:], keysForLabels[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Zones) > 0 {
		for iNdEx := len(m.Zones) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Zones[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ResourceWatchCacheSize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i = encodeVarintGenerated(dAtA, i, uint64(m.CacheSize))
	i--
	dAtA[i] = 0x18
	i -= len(m.Resource)
	copy(dAtA[i:], m.Resource)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
	i--
	dAtA[i] = 0x12
	if m.APIGroup != nil {
		i -= len(*m.APIGroup)
		copy(dAtA[i:], *m.APIGroup)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.APIGroup)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SecretBinding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Quotas) > 0 {
		for iNdEx := len(m.Quotas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Quotas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *Seed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *SeedBackup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Region != nil {
		i -= len(*m.Region)
		copy(dAtA[i:], *m.Region)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Region)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Provider)
	copy(dAtA[i:], m.Provider)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Provider)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *SeedDNS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Provider != nil {
		{
			size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.IngressDomain != nil {
		i -= len(*m.IngressDomain)
		copy(dAtA[i:], *m.IngressDomain)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.IngressDomain)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SeedDNSProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Zones != nil {
		{
			size, err := m.Zones.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Domains != nil {
		{
			size, err := m.Domains.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SeedNetworks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ShootDefaults != nil {
		{
			size, err := m.ShootDefaults.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	i -= len(m.Services)
	copy(dAtA[i:], m.Services)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Services)))
	i--
	dAtA[i] = 0x1a
	i -= len(m.Pods)
	copy(dAtA[i:], m.Pods)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Pods)))
	i--
	dAtA[i] = 0x12
	if m.Nodes != nil {
		i -= len(*m.Nodes)
		copy(dAtA[i:], *m.Nodes)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Nodes)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SeedProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Region)
	copy(dAtA[i:], m.Region)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
	i--
	dAtA[i] = 0x1a
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Type)
	copy(dAtA[i:], m.Type)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SeedSettingExcessCapacityReservation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSettingLoadBalancerServices) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		keysForAnnotations := make([]string, 0, len(m.Annotations))
		for k := range m.Annotations {
			keysForAnnotations = append(keysForAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Annotations[string(keysForAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForAnnotations[iNdEx])
			copy(dAtA[i:], keysForAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSettingScheduling) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Visible {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSettingShootDNS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSettingVerticalPodAutoscaler) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VerticalPodAutoscaler != nil {
		{
			size, err := m.VerticalPodAutoscaler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.LoadBalancerServices != nil {
		{
			size, err := m.LoadBalancerServices.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ShootDNS != nil {
		{
			size, err := m.ShootDNS.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Scheduling != nil {
		{
			size, err := m.Scheduling.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ExcessCapacityReservation != nil {
		{
			size, err := m.ExcessCapacityReservation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SeedSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ingress != nil {
		{
			size, err := m.Ingress.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Settings != nil {
		{
			size, err := m.Settings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Volume != nil {
		{
			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.SecretRef != nil {
		{
			size, err := m.SecretRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	{
		size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Networks.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.DNS.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.BlockCIDRs) > 0 {
		for iNdEx := len(m.BlockCIDRs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockCIDRs[iNdEx])
			copy(dAtA[i:], m.BlockCIDRs[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.BlockCIDRs[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Backup != nil {
		{
			size, err := m.Backup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SeedStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClusterIdentity != nil {
		i -= len(*m.ClusterIdentity)
		copy(dAtA[i:], *m.ClusterIdentity)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ClusterIdentity)))
		i--
		dAtA[i] = 0x2a
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
	i--
	dAtA[i] = 0x20
	if m.KubernetesVersion != nil {
		i -= len(*m.KubernetesVersion)
		copy(dAtA[i:], *m.KubernetesVersion)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.KubernetesVersion)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Gardener != nil {
		{
			size, err := m.Gardener.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *SeedVolumeProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Purpose)
	copy(dAtA[i:], m.Purpose)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Purpose)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ServiceAccountConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SigningKeySecret != nil {
		{
			size, err := m.SigningKeySecret.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Issuer != nil {
		i -= len(*m.Issuer)
		copy(dAtA[i:], *m.Issuer)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Issuer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Shoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ShootMachineImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != nil {
		i -= len(*m.Version)
		copy(dAtA[i:], *m.Version)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Version)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ShootNetworks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Services != nil {
		i -= len(*m.Services)
		copy(dAtA[i:], *m.Services)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Services)))
		i--
		dAtA[i] = 0x12
	}
	if m.Pods != nil {
		i -= len(*m.Pods)
		copy(dAtA[i:], *m.Pods)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Pods)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ShootSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tolerations) > 0 {
		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.Resources) > 0 {
		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Resources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if m.SeedSelector != nil {
		{
			size, err := m.SeedSelector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.SeedName != nil {
		i -= len(*m.SeedName)
		copy(dAtA[i:], *m.SeedName)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SeedName)))
		i--
		dAtA[i] = 0x72
	}
	i -= len(m.SecretBindingName)
	copy(dAtA[i:], m.SecretBindingName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretBindingName)))
	i--
	dAtA[i] = 0x6a
	i -= len(m.Region)
	copy(dAtA[i:], m.Region)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Region)))
	i--
	dAtA[i] = 0x62
	if m.Purpose != nil {
		i -= len(*m.Purpose)
		copy(dAtA[i:], *m.Purpose)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Purpose)))
		i--
		dAtA[i] = 0x5a
	}
	{
		size, err := m.Provider.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	if m.Monitoring != nil {
		{
			size, err := m.Monitoring.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Maintenance != nil {
		{
			size, err := m.Maintenance.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	{
		size, err := m.Networking.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.Kubernetes.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if m.Hibernation != nil {
		{
			size, err := m.Hibernation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Extensions) > 0 {
		for iNdEx := len(m.Extensions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Extensions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.DNS != nil {
		{
			size, err := m.DNS.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	i -= len(m.CloudProfileName)
	copy(dAtA[i:], m.CloudProfileName)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CloudProfileName)))
	i--
	dAtA[i] = 0x12
	if m.Addons != nil {
		{
			size, err := m.Addons.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *ShootStateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Resources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Extensions) > 0 {
		for iNdEx := len(m.Extensions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Extensions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Gardener) > 0 {
		for iNdEx := len(m.Gardener) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Gardener[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ShootStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClusterIdentity != nil {
		i -= len(*m.ClusterIdentity)
		copy(dAtA[i:], *m.ClusterIdentity)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ClusterIdentity)))
		i--
		dAtA[i] = 0x6a
	}
	i -= len(m.UID)
	copy(dAtA[i:], m.UID)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
	i--
	dAtA[i] = 0x62
	i -= len(m.TechnicalID)
	copy(dAtA[i:], m.TechnicalID)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TechnicalID)))
	i--
	dAtA[i] = 0x5a
	if m.Seed != nil {
		i -= len(*m.Seed)
		copy(dAtA[i:], *m.Seed)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Seed)))
		i--
		dAtA[i] = 0x52
	}
	if m.RetryCycleStartTime != nil {
		{
			size, err := m.RetryCycleStartTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
	i--
	dAtA[i] = 0x40
	if len(m.LastErrors) > 0 {
		for iNdEx := len(m.LastErrors) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LastErrors[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.LastError != nil {
		{
			size, err := m.LastError.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.LastOperation != nil {
		{
			size, err := m.LastOperation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	i--
	if m.IsHibernated {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	{
		size, err := m.Gardener.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Constraints) > 0 {
		for iNdEx := len(m.Constraints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Constraints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *VerticalPodAutoscaler) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RecommenderInterval != nil {
		{
			size, err := m.RecommenderInterval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.UpdaterInterval != nil {
		{
			size, err := m.UpdaterInterval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.RecommendationMarginFraction != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.RecommendationMarginFraction))))
		i--
		dAtA[i] = 0x31
	}
	if m.EvictionTolerance != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.EvictionTolerance))))
		i--
		dAtA[i] = 0x29
	}
	if m.EvictionRateLimit != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.EvictionRateLimit))))
		i--
		dAtA[i] = 0x21
	}
	if m.EvictionRateBurst != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.EvictionRateBurst))
		i--
		dAtA[i] = 0x18
	}
	if m.EvictAfterOOMThreshold != nil {
		{
			size, err := m.EvictAfterOOMThreshold.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	i--
	if m.Enabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

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

func (m *Volume) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Encrypted != nil {
		i--
		if *m.Encrypted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	i -= len(m.VolumeSize)
	copy(dAtA[i:], m.VolumeSize)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.VolumeSize)))
	i--
	dAtA[i] = 0x1a
	if m.Type != nil {
		i -= len(*m.Type)
		copy(dAtA[i:], *m.Type)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if m.Name != nil {
		i -= len(*m.Name)
		copy(dAtA[i:], *m.Name)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *VolumeType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Usable != nil {
		i--
		if *m.Usable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x12
	i -= len(m.Class)
	copy(dAtA[i:], m.Class)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Class)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *WatchCacheSizes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Resources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Default != nil {
		i = encodeVarintGenerated(dAtA, i, uint64(*m.Default))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Worker) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MachineControllerManagerSettings != nil {
		{
			size, err := m.MachineControllerManagerSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.SystemComponents != nil {
		{
			size, err := m.SystemComponents.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.Zones) > 0 {
		for iNdEx := len(m.Zones) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Zones[iNdEx])
			copy(dAtA[i:], m.Zones[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Zones[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if m.KubeletDataVolumeName != nil {
		i -= len(*m.KubeletDataVolumeName)
		copy(dAtA[i:], *m.KubeletDataVolumeName)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.KubeletDataVolumeName)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.DataVolumes) > 0 {
		for iNdEx := len(m.DataVolumes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DataVolumes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x7a
		}
	}
	if m.Volume != nil {
		{
			size, err := m.Volume.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenerated(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6a
		}
	}
	if m.ProviderConfig != nil {
		{
			size, err := m.ProviderConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.MaxUnavailable != nil {
		{
			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.MaxSurge != nil {
		{
			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	i = encodeVarintGenerated(dAtA, i, uint64(m.Minimum))
	i--
	dAtA[i] = 0x48
	i = encodeVarintGenerated(dAtA, i, uint64(m.Maximum))
	i--
	dAtA[i] = 0x40
	{
		size, err := m.Machine.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	i -= len(m.Name)
	copy(dAtA[i:], m.Name)
	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
	i--
	dAtA[i] = 0x32
	if len(m.Labels) > 0 {
		keysForLabels := make([]string, 0, len(m.Labels))
		for k := range m.Labels {
			keysForLabels = append(keysForLabels, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
		for iNdEx := len(keysForLabels) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Labels[string(keysForLabels[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForLabels[iNdEx])
			copy(dAtA[i:], keysForLabels[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForLabels[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Kubernetes != nil {
		{
			size, err := m.Kubernetes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.CRI != nil {
		{
			size, err := m.CRI.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenerated(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.CABundle != nil {
		i -= len(*m.CABundle)
		copy(dAtA[i:], *m.CABundle)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.CABundle)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Annotations) > 0 {
		keysForAnnotations := make([]string, 0, len(m.Annotations))
		for k := range m.Annotations {
			keysForAnnotations = append(keysForAnnotations, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
		for iNdEx := len(keysForAnnotations) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Annotations[string(keysForAnnotations[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForAnnotations[iNdEx])
			copy(dAtA[i:], keysForAnnotations[iNdEx])
			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAnnotations[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *WorkerSystemComponents) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	i--
	if m.Allow {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenerated(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Addon) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func (m *Addons) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KubernetesDashboard != nil {
		l = m.KubernetesDashboard.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NginxIngress != nil {
		l = m.NginxIngress.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *AdmissionPlugin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Alerting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.EmailReceivers) > 0 {
		for _, s := range m.EmailReceivers {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *AuditConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AuditPolicy != nil {
		l = m.AuditPolicy.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *AuditPolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConfigMapRef != nil {
		l = m.ConfigMapRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *AvailabilityZone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.UnavailableMachineTypes) > 0 {
		for _, s := range m.UnavailableMachineTypes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.UnavailableVolumeTypes) > 0 {
		for _, s := range m.UnavailableVolumeTypes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *BackupBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *BackupBucketProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *BackupBucketSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Provider.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.SecretRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Seed != nil {
		l = len(*m.Seed)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *BackupBucketStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProviderStatus != nil {
		l = m.ProviderStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.LastOperation != nil {
		l = m.LastOperation.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.LastError != nil {
		l = m.LastError.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
	if m.GeneratedSecretRef != nil {
		l = m.GeneratedSecretRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *BackupEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *BackupEntrySpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BucketName)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Seed != nil {
		l = len(*m.Seed)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *BackupEntryStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LastOperation != nil {
		l = m.LastOperation.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.LastError != nil {
		l = m.LastError.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
	return n
}

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

func (m *CloudInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *CloudProfile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *CloudProfileSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CABundle != nil {
		l = len(*m.CABundle)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Kubernetes.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.MachineImages) > 0 {
		for _, e := range m.MachineImages {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.MachineTypes) > 0 {
		for _, e := range m.MachineTypes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Regions) > 0 {
		for _, e := range m.Regions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.SeedSelector != nil {
		l = m.SeedSelector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.VolumeTypes) > 0 {
		for _, e := range m.VolumeTypes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *ClusterAutoscaler) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScaleDownDelayAfterAdd != nil {
		l = m.ScaleDownDelayAfterAdd.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownDelayAfterDelete != nil {
		l = m.ScaleDownDelayAfterDelete.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownDelayAfterFailure != nil {
		l = m.ScaleDownDelayAfterFailure.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownUnneededTime != nil {
		l = m.ScaleDownUnneededTime.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ScaleDownUtilizationThreshold != nil {
		n += 9
	}
	if m.ScanInterval != nil {
		l = m.ScanInterval.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ClusterInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Cloud.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Kubernetes.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Condition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Status)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastTransitionTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastUpdateTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Reason)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Message)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Codes) > 0 {
		for _, s := range m.Codes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *ContainerRuntime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ControllerDeployment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Policy != nil {
		l = len(*m.Policy)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SeedSelector != nil {
		l = m.SeedSelector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ControllerInstallation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *ControllerInstallationSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.RegistrationRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.SeedRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ControllerInstallationStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.ProviderStatus != nil {
		l = m.ProviderStatus.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ControllerRegistration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *ControllerRegistrationSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Deployment != nil {
		l = m.Deployment.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ControllerResource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.GloballyEnabled != nil {
		n += 2
	}
	if m.ReconcileTimeout != nil {
		l = m.ReconcileTimeout.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Primary != nil {
		n += 2
	}
	return n
}

func (m *DNS) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Domain != nil {
		l = len(*m.Domain)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Providers) > 0 {
		for _, e := range m.Providers {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *DNSIncludeExclude) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Include) > 0 {
		for _, s := range m.Include {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Exclude) > 0 {
		for _, s := range m.Exclude {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *DNSProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Domains != nil {
		l = m.Domains.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Primary != nil {
		n += 2
	}
	if m.SecretName != nil {
		l = len(*m.SecretName)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Type != nil {
		l = len(*m.Type)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Zones != nil {
		l = m.Zones.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *DataVolume) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Type != nil {
		l = len(*m.Type)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.VolumeSize)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Encrypted != nil {
		n += 2
	}
	return n
}

func (m *Endpoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.URL)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Purpose)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ExpirableVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ExpirationDate != nil {
		l = m.ExpirationDate.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Classification != nil {
		l = len(*m.Classification)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Extension) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Disabled != nil {
		n += 2
	}
	return n
}

func (m *ExtensionResourceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Purpose != nil {
		l = len(*m.Purpose)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *Gardener) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Version)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *GardenerResourceData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Data.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Hibernation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enabled != nil {
		n += 2
	}
	if len(m.Schedules) > 0 {
		for _, e := range m.Schedules {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *HibernationSchedule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != nil {
		l = len(*m.Start)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.End != nil {
		l = len(*m.End)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Location != nil {
		l = len(*m.Location)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *HorizontalPodAutoscalerConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CPUInitializationPeriod != nil {
		l = m.CPUInitializationPeriod.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.DownscaleDelay != nil {
		l = m.DownscaleDelay.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.DownscaleStabilization != nil {
		l = m.DownscaleStabilization.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.InitialReadinessDelay != nil {
		l = m.InitialReadinessDelay.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SyncPeriod != nil {
		l = m.SyncPeriod.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Tolerance != nil {
		n += 9
	}
	if m.UpscaleDelay != nil {
		l = m.UpscaleDelay.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Ingress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Domain)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Controller.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *IngressController) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeAPIServerConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KubernetesConfig.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.AdmissionPlugins) > 0 {
		for _, e := range m.AdmissionPlugins {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.APIAudiences) > 0 {
		for _, s := range m.APIAudiences {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.AuditConfig != nil {
		l = m.AuditConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EnableBasicAuthentication != nil {
		n += 2
	}
	if m.OIDCConfig != nil {
		l = m.OIDCConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.RuntimeConfig) > 0 {
		for k, v := range m.RuntimeConfig {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if m.ServiceAccountConfig != nil {
		l = m.ServiceAccountConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.WatchCacheSizes != nil {
		l = m.WatchCacheSizes.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Requests != nil {
		l = m.Requests.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeAPIServerRequests) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxNonMutatingInflight != nil {
		n += 1 + sovGenerated(uint64(*m.MaxNonMutatingInflight))
	}
	if m.MaxMutatingInflight != nil {
		n += 1 + sovGenerated(uint64(*m.MaxMutatingInflight))
	}
	return n
}

func (m *KubeControllerManagerConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KubernetesConfig.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.HorizontalPodAutoscalerConfig != nil {
		l = m.HorizontalPodAutoscalerConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeCIDRMaskSize != nil {
		n += 1 + sovGenerated(uint64(*m.NodeCIDRMaskSize))
	}
	if m.PodEvictionTimeout != nil {
		l = m.PodEvictionTimeout.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeProxyConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KubernetesConfig.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Mode != nil {
		l = len(*m.Mode)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeSchedulerConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KubernetesConfig.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.KubeMaxPDVols != nil {
		l = len(*m.KubeMaxPDVols)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeletConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.KubernetesConfig.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.CPUCFSQuota != nil {
		n += 2
	}
	if m.CPUManagerPolicy != nil {
		l = len(*m.CPUManagerPolicy)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionHard != nil {
		l = m.EvictionHard.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionMaxPodGracePeriod != nil {
		n += 1 + sovGenerated(uint64(*m.EvictionMaxPodGracePeriod))
	}
	if m.EvictionMinimumReclaim != nil {
		l = m.EvictionMinimumReclaim.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionPressureTransitionPeriod != nil {
		l = m.EvictionPressureTransitionPeriod.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionSoft != nil {
		l = m.EvictionSoft.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionSoftGracePeriod != nil {
		l = m.EvictionSoftGracePeriod.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MaxPods != nil {
		n += 1 + sovGenerated(uint64(*m.MaxPods))
	}
	if m.PodPIDsLimit != nil {
		n += 1 + sovGenerated(uint64(*m.PodPIDsLimit))
	}
	if m.ImagePullProgressDeadline != nil {
		l = m.ImagePullProgressDeadline.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.FailSwapOn != nil {
		n += 2
	}
	if m.KubeReserved != nil {
		l = m.KubeReserved.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SystemReserved != nil {
		l = m.SystemReserved.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeletConfigEviction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryAvailable != nil {
		l = len(*m.MemoryAvailable)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSAvailable != nil {
		l = len(*m.ImageFSAvailable)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSInodesFree != nil {
		l = len(*m.ImageFSInodesFree)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSAvailable != nil {
		l = len(*m.NodeFSAvailable)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSInodesFree != nil {
		l = len(*m.NodeFSInodesFree)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeletConfigEvictionMinimumReclaim) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryAvailable != nil {
		l = m.MemoryAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSAvailable != nil {
		l = m.ImageFSAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSInodesFree != nil {
		l = m.ImageFSInodesFree.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSAvailable != nil {
		l = m.NodeFSAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSInodesFree != nil {
		l = m.NodeFSInodesFree.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeletConfigEvictionSoftGracePeriod) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryAvailable != nil {
		l = m.MemoryAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSAvailable != nil {
		l = m.ImageFSAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ImageFSInodesFree != nil {
		l = m.ImageFSInodesFree.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSAvailable != nil {
		l = m.NodeFSAvailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.NodeFSInodesFree != nil {
		l = m.NodeFSInodesFree.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubeletConfigReserved) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CPU != nil {
		l = m.CPU.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EphemeralStorage != nil {
		l = m.EphemeralStorage.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.PID != nil {
		l = m.PID.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Kubernetes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AllowPrivilegedContainers != nil {
		n += 2
	}
	if m.ClusterAutoscaler != nil {
		l = m.ClusterAutoscaler.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.KubeAPIServer != nil {
		l = m.KubeAPIServer.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.KubeControllerManager != nil {
		l = m.KubeControllerManager.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.KubeScheduler != nil {
		l = m.KubeScheduler.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.KubeProxy != nil {
		l = m.KubeProxy.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Kubelet != nil {
		l = m.Kubelet.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Version)
	n += 1 + l + sovGenerated(uint64(l))
	if m.VerticalPodAutoscaler != nil {
		l = m.VerticalPodAutoscaler.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *KubernetesConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.FeatureGates) > 0 {
		for k, v := range m.FeatureGates {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *KubernetesDashboard) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AuthenticationMode != nil {
		l = len(*m.AuthenticationMode)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Addon.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *KubernetesInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *LastError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	n += 1 + l + sovGenerated(uint64(l))
	if m.TaskID != nil {
		l = len(*m.TaskID)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Codes) > 0 {
		for _, s := range m.Codes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.LastUpdateTime != nil {
		l = m.LastUpdateTime.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *LastOperation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.LastUpdateTime.Size()
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Progress))
	l = len(m.State)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Machine) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Image != nil {
		l = m.Image.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *MachineControllerManagerSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MachineDrainTimeout != nil {
		l = m.MachineDrainTimeout.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MachineHealthTimeout != nil {
		l = m.MachineHealthTimeout.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MachineCreationTimeout != nil {
		l = m.MachineCreationTimeout.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MaxEvictRetries != nil {
		n += 1 + sovGenerated(uint64(*m.MaxEvictRetries))
	}
	if len(m.NodeConditions) > 0 {
		for _, s := range m.NodeConditions {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

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

func (m *MachineType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CPU.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.GPU.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Memory.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Storage != nil {
		l = m.Storage.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Usable != nil {
		n += 2
	}
	return n
}

func (m *MachineTypeStorage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Class)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.StorageSize.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Maintenance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AutoUpdate != nil {
		l = m.AutoUpdate.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.TimeWindow != nil {
		l = m.TimeWindow.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ConfineSpecUpdateRollout != nil {
		n += 2
	}
	return n
}

func (m *MaintenanceAutoUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	n += 2
	return n
}

func (m *MaintenanceTimeWindow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Begin)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.End)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Monitoring) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Alerting != nil {
		l = m.Alerting.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *NamedResourceReference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.ResourceRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Networking) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Pods != nil {
		l = len(*m.Pods)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Nodes != nil {
		l = len(*m.Nodes)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Services != nil {
		l = len(*m.Services)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *NginxIngress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LoadBalancerSourceRanges) > 0 {
		for _, s := range m.LoadBalancerSourceRanges {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Config) > 0 {
		for k, v := range m.Config {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if m.ExternalTrafficPolicy != nil {
		l = len(*m.ExternalTrafficPolicy)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Addon.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *OIDCConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CABundle != nil {
		l = len(*m.CABundle)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ClientAuthentication != nil {
		l = m.ClientAuthentication.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ClientID != nil {
		l = len(*m.ClientID)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.GroupsClaim != nil {
		l = len(*m.GroupsClaim)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.GroupsPrefix != nil {
		l = len(*m.GroupsPrefix)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.IssuerURL != nil {
		l = len(*m.IssuerURL)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.RequiredClaims) > 0 {
		for k, v := range m.RequiredClaims {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.SigningAlgs) > 0 {
		for _, s := range m.SigningAlgs {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.UsernameClaim != nil {
		l = len(*m.UsernameClaim)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.UsernamePrefix != nil {
		l = len(*m.UsernamePrefix)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *OpenIDConnectClientAuthentication) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ExtraConfig) > 0 {
		for k, v := range m.ExtraConfig {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if m.Secret != nil {
		l = len(*m.Secret)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Plant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

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

func (m *PlantStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.ObservedGeneration != nil {
		n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
	}
	if m.ClusterInfo != nil {
		l = m.ClusterInfo.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Project) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *ProjectMember) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Subject.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Role)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Roles) > 0 {
		for _, s := range m.Roles {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *ProjectSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreatedBy != nil {
		l = m.CreatedBy.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Description != nil {
		l = len(*m.Description)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Owner != nil {
		l = m.Owner.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Purpose != nil {
		l = len(*m.Purpose)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Members) > 0 {
		for _, e := range m.Members {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Namespace != nil {
		l = len(*m.Namespace)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Tolerations != nil {
		l = m.Tolerations.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ProjectStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
	l = len(m.Phase)
	n += 1 + l + sovGenerated(uint64(l))
	if m.StaleSinceTimestamp != nil {
		l = m.StaleSinceTimestamp.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.StaleAutoDeleteTimestamp != nil {
		l = m.StaleAutoDeleteTimestamp.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

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

func (m *Provider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ControlPlaneConfig != nil {
		l = m.ControlPlaneConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.InfrastructureConfig != nil {
		l = m.InfrastructureConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Workers) > 0 {
		for _, e := range m.Workers {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *Quota) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *QuotaSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClusterLifetimeDays != nil {
		n += 1 + sovGenerated(uint64(*m.ClusterLifetimeDays))
	}
	if len(m.Metrics) > 0 {
		for k, v := range m.Metrics {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	l = m.Scope.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *Region) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Zones) > 0 {
		for _, e := range m.Zones {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ResourceData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CrossVersionObjectReference.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Data.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ResourceWatchCacheSize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.APIGroup != nil {
		l = len(*m.APIGroup)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Resource)
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.CacheSize))
	return n
}

func (m *SecretBinding) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.SecretRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if len(m.Quotas) > 0 {
		for _, e := range m.Quotas {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

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

func (m *Seed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *SeedBackup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Provider)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Region != nil {
		l = len(*m.Region)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.SecretRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *SeedDNS) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IngressDomain != nil {
		l = len(*m.IngressDomain)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Provider != nil {
		l = m.Provider.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *SeedDNSProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.SecretRef.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Domains != nil {
		l = m.Domains.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Zones != nil {
		l = m.Zones.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

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

func (m *SeedNetworks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Nodes != nil {
		l = len(*m.Nodes)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Pods)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Services)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ShootDefaults != nil {
		l = m.ShootDefaults.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *SeedProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *SeedSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LabelSelector != nil {
		l = m.LabelSelector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.ProviderTypes) > 0 {
		for _, s := range m.ProviderTypes {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *SeedSettingExcessCapacityReservation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func (m *SeedSettingLoadBalancerServices) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *SeedSettingScheduling) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func (m *SeedSettingShootDNS) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func (m *SeedSettingVerticalPodAutoscaler) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func (m *SeedSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExcessCapacityReservation != nil {
		l = m.ExcessCapacityReservation.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Scheduling != nil {
		l = m.Scheduling.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ShootDNS != nil {
		l = m.ShootDNS.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.LoadBalancerServices != nil {
		l = m.LoadBalancerServices.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.VerticalPodAutoscaler != nil {
		l = m.VerticalPodAutoscaler.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *SeedSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Backup != nil {
		l = m.Backup.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.BlockCIDRs) > 0 {
		for _, s := range m.BlockCIDRs {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = m.DNS.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Networks.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Provider.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.SecretRef != nil {
		l = m.SecretRef.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Volume != nil {
		l = m.Volume.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Settings != nil {
		l = m.Settings.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Ingress != nil {
		l = m.Ingress.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *SeedStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Gardener != nil {
		l = m.Gardener.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.KubernetesVersion != nil {
		l = len(*m.KubernetesVersion)
		n += 1 + l + sovGenerated(uint64(l))
	}
	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
	if m.ClusterIdentity != nil {
		l = len(*m.ClusterIdentity)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

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

func (m *SeedVolume) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinimumSize != nil {
		l = m.MinimumSize.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Providers) > 0 {
		for _, e := range m.Providers {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *SeedVolumeProvider) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Purpose)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *ServiceAccountConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Issuer != nil {
		l = len(*m.Issuer)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SigningKeySecret != nil {
		l = m.SigningKeySecret.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Shoot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Status.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *ShootMachineImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Version != nil {
		l = len(*m.Version)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ShootNetworks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pods != nil {
		l = len(*m.Pods)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Services != nil {
		l = len(*m.Services)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *ShootSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Addons != nil {
		l = m.Addons.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.CloudProfileName)
	n += 1 + l + sovGenerated(uint64(l))
	if m.DNS != nil {
		l = m.DNS.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Extensions) > 0 {
		for _, e := range m.Extensions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Hibernation != nil {
		l = m.Hibernation.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Kubernetes.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Networking.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Maintenance != nil {
		l = m.Maintenance.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Monitoring != nil {
		l = m.Monitoring.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Provider.Size()
	n += 1 + l + sovGenerated(uint64(l))
	if m.Purpose != nil {
		l = len(*m.Purpose)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.Region)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.SecretBindingName)
	n += 1 + l + sovGenerated(uint64(l))
	if m.SeedName != nil {
		l = len(*m.SeedName)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.SeedSelector != nil {
		l = m.SeedSelector.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 2 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Tolerations) > 0 {
		for _, e := range m.Tolerations {
			l = e.Size()
			n += 2 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *ShootState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Spec.Size()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

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

func (m *ShootStateSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Gardener) > 0 {
		for _, e := range m.Gardener {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Extensions) > 0 {
		for _, e := range m.Extensions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *ShootStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if len(m.Constraints) > 0 {
		for _, e := range m.Constraints {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	l = m.Gardener.Size()
	n += 1 + l + sovGenerated(uint64(l))
	n += 2
	if m.LastOperation != nil {
		l = m.LastOperation.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.LastError != nil {
		l = m.LastError.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.LastErrors) > 0 {
		for _, e := range m.LastErrors {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
	if m.RetryCycleStartTime != nil {
		l = m.RetryCycleStartTime.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Seed != nil {
		l = len(*m.Seed)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.TechnicalID)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.UID)
	n += 1 + l + sovGenerated(uint64(l))
	if m.ClusterIdentity != nil {
		l = len(*m.ClusterIdentity)
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

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

func (m *VerticalPodAutoscaler) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	if m.EvictAfterOOMThreshold != nil {
		l = m.EvictAfterOOMThreshold.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.EvictionRateBurst != nil {
		n += 1 + sovGenerated(uint64(*m.EvictionRateBurst))
	}
	if m.EvictionRateLimit != nil {
		n += 9
	}
	if m.EvictionTolerance != nil {
		n += 9
	}
	if m.RecommendationMarginFraction != nil {
		n += 9
	}
	if m.UpdaterInterval != nil {
		l = m.UpdaterInterval.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.RecommenderInterval != nil {
		l = m.RecommenderInterval.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Volume) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Type != nil {
		l = len(*m.Type)
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = len(m.VolumeSize)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Encrypted != nil {
		n += 2
	}
	return n
}

func (m *VolumeType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Class)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	if m.Usable != nil {
		n += 2
	}
	return n
}

func (m *WatchCacheSizes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Default != nil {
		n += 1 + sovGenerated(uint64(*m.Default))
	}
	if len(m.Resources) > 0 {
		for _, e := range m.Resources {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	return n
}

func (m *Worker) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if m.CABundle != nil {
		l = len(*m.CABundle)
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.CRI != nil {
		l = m.CRI.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Kubernetes != nil {
		l = m.Kubernetes.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	l = len(m.Name)
	n += 1 + l + sovGenerated(uint64(l))
	l = m.Machine.Size()
	n += 1 + l + sovGenerated(uint64(l))
	n += 1 + sovGenerated(uint64(m.Maximum))
	n += 1 + sovGenerated(uint64(m.Minimum))
	if m.MaxSurge != nil {
		l = m.MaxSurge.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.MaxUnavailable != nil {
		l = m.MaxUnavailable.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.ProviderConfig != nil {
		l = m.ProviderConfig.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.Volume != nil {
		l = m.Volume.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.DataVolumes) > 0 {
		for _, e := range m.DataVolumes {
			l = e.Size()
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.KubeletDataVolumeName != nil {
		l = len(*m.KubeletDataVolumeName)
		n += 2 + l + sovGenerated(uint64(l))
	}
	if len(m.Zones) > 0 {
		for _, s := range m.Zones {
			l = len(s)
			n += 2 + l + sovGenerated(uint64(l))
		}
	}
	if m.SystemComponents != nil {
		l = m.SystemComponents.Size()
		n += 2 + l + sovGenerated(uint64(l))
	}
	if m.MachineControllerManagerSettings != nil {
		l = m.MachineControllerManagerSettings.Size()
		n += 2 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *WorkerKubernetes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Kubelet != nil {
		l = m.Kubelet.Size()
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *WorkerSystemComponents) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}

func sovGenerated(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenerated(x uint64) (n int) {
	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Addon) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Addon{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Addons) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Addons{`,
		`KubernetesDashboard:` + strings.Replace(this.KubernetesDashboard.String(), "KubernetesDashboard", "KubernetesDashboard", 1) + `,`,
		`NginxIngress:` + strings.Replace(this.NginxIngress.String(), "NginxIngress", "NginxIngress", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AdmissionPlugin) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AdmissionPlugin{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Config:` + strings.Replace(fmt.Sprintf("%v", this.Config), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Alerting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Alerting{`,
		`EmailReceivers:` + fmt.Sprintf("%v", this.EmailReceivers) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AuditConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AuditConfig{`,
		`AuditPolicy:` + strings.Replace(this.AuditPolicy.String(), "AuditPolicy", "AuditPolicy", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AuditPolicy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AuditPolicy{`,
		`ConfigMapRef:` + strings.Replace(fmt.Sprintf("%v", this.ConfigMapRef), "ObjectReference", "v1.ObjectReference", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AvailabilityZone) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AvailabilityZone{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UnavailableMachineTypes:` + fmt.Sprintf("%v", this.UnavailableMachineTypes) + `,`,
		`UnavailableVolumeTypes:` + fmt.Sprintf("%v", this.UnavailableVolumeTypes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupBucket) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupBucket{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "BackupBucketSpec", "BackupBucketSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "BackupBucketStatus", "BackupBucketStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupBucketList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]BackupBucket{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "BackupBucket", "BackupBucket", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&BackupBucketList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupBucketProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupBucketProvider{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupBucketSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupBucketSpec{`,
		`Provider:` + strings.Replace(strings.Replace(this.Provider.String(), "BackupBucketProvider", "BackupBucketProvider", 1), `&`, ``, 1) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`SecretRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretRef), "SecretReference", "v1.SecretReference", 1), `&`, ``, 1) + `,`,
		`Seed:` + valueToStringGenerated(this.Seed) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupBucketStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupBucketStatus{`,
		`ProviderStatus:` + strings.Replace(fmt.Sprintf("%v", this.ProviderStatus), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`LastOperation:` + strings.Replace(this.LastOperation.String(), "LastOperation", "LastOperation", 1) + `,`,
		`LastError:` + strings.Replace(this.LastError.String(), "LastError", "LastError", 1) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`GeneratedSecretRef:` + strings.Replace(fmt.Sprintf("%v", this.GeneratedSecretRef), "SecretReference", "v1.SecretReference", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupEntry) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupEntry{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "BackupEntrySpec", "BackupEntrySpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "BackupEntryStatus", "BackupEntryStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupEntryList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]BackupEntry{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "BackupEntry", "BackupEntry", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&BackupEntryList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupEntrySpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupEntrySpec{`,
		`BucketName:` + fmt.Sprintf("%v", this.BucketName) + `,`,
		`Seed:` + valueToStringGenerated(this.Seed) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BackupEntryStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BackupEntryStatus{`,
		`LastOperation:` + strings.Replace(this.LastOperation.String(), "LastOperation", "LastOperation", 1) + `,`,
		`LastError:` + strings.Replace(this.LastError.String(), "LastError", "LastError", 1) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CRI) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForContainerRuntimes := "[]ContainerRuntime{"
	for _, f := range this.ContainerRuntimes {
		repeatedStringForContainerRuntimes += strings.Replace(strings.Replace(f.String(), "ContainerRuntime", "ContainerRuntime", 1), `&`, ``, 1) + ","
	}
	repeatedStringForContainerRuntimes += "}"
	s := strings.Join([]string{`&CRI{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ContainerRuntimes:` + repeatedStringForContainerRuntimes + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CloudInfo{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudProfile) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CloudProfile{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CloudProfileSpec", "CloudProfileSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudProfileList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]CloudProfile{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CloudProfile", "CloudProfile", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&CloudProfileList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *CloudProfileSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMachineImages := "[]MachineImage{"
	for _, f := range this.MachineImages {
		repeatedStringForMachineImages += strings.Replace(strings.Replace(f.String(), "MachineImage", "MachineImage", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMachineImages += "}"
	repeatedStringForMachineTypes := "[]MachineType{"
	for _, f := range this.MachineTypes {
		repeatedStringForMachineTypes += strings.Replace(strings.Replace(f.String(), "MachineType", "MachineType", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMachineTypes += "}"
	repeatedStringForRegions := "[]Region{"
	for _, f := range this.Regions {
		repeatedStringForRegions += strings.Replace(strings.Replace(f.String(), "Region", "Region", 1), `&`, ``, 1) + ","
	}
	repeatedStringForRegions += "}"
	repeatedStringForVolumeTypes := "[]VolumeType{"
	for _, f := range this.VolumeTypes {
		repeatedStringForVolumeTypes += strings.Replace(strings.Replace(f.String(), "VolumeType", "VolumeType", 1), `&`, ``, 1) + ","
	}
	repeatedStringForVolumeTypes += "}"
	s := strings.Join([]string{`&CloudProfileSpec{`,
		`CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
		`Kubernetes:` + strings.Replace(strings.Replace(this.Kubernetes.String(), "KubernetesSettings", "KubernetesSettings", 1), `&`, ``, 1) + `,`,
		`MachineImages:` + repeatedStringForMachineImages + `,`,
		`MachineTypes:` + repeatedStringForMachineTypes + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Regions:` + repeatedStringForRegions + `,`,
		`SeedSelector:` + strings.Replace(this.SeedSelector.String(), "SeedSelector", "SeedSelector", 1) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`VolumeTypes:` + repeatedStringForVolumeTypes + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterAutoscaler) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClusterAutoscaler{`,
		`ScaleDownDelayAfterAdd:` + strings.Replace(fmt.Sprintf("%v", this.ScaleDownDelayAfterAdd), "Duration", "v11.Duration", 1) + `,`,
		`ScaleDownDelayAfterDelete:` + strings.Replace(fmt.Sprintf("%v", this.ScaleDownDelayAfterDelete), "Duration", "v11.Duration", 1) + `,`,
		`ScaleDownDelayAfterFailure:` + strings.Replace(fmt.Sprintf("%v", this.ScaleDownDelayAfterFailure), "Duration", "v11.Duration", 1) + `,`,
		`ScaleDownUnneededTime:` + strings.Replace(fmt.Sprintf("%v", this.ScaleDownUnneededTime), "Duration", "v11.Duration", 1) + `,`,
		`ScaleDownUtilizationThreshold:` + valueToStringGenerated(this.ScaleDownUtilizationThreshold) + `,`,
		`ScanInterval:` + strings.Replace(fmt.Sprintf("%v", this.ScanInterval), "Duration", "v11.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClusterInfo{`,
		`Cloud:` + strings.Replace(strings.Replace(this.Cloud.String(), "CloudInfo", "CloudInfo", 1), `&`, ``, 1) + `,`,
		`Kubernetes:` + strings.Replace(strings.Replace(this.Kubernetes.String(), "KubernetesInfo", "KubernetesInfo", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Condition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Condition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v11.Time", 1), `&`, ``, 1) + `,`,
		`LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v11.Time", 1), `&`, ``, 1) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Codes:` + fmt.Sprintf("%v", this.Codes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerRuntime) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainerRuntime{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerDeployment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ControllerDeployment{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Policy:` + valueToStringGenerated(this.Policy) + `,`,
		`SeedSelector:` + strings.Replace(fmt.Sprintf("%v", this.SeedSelector), "LabelSelector", "v11.LabelSelector", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerInstallation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ControllerInstallation{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ControllerInstallationSpec", "ControllerInstallationSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ControllerInstallationStatus", "ControllerInstallationStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerInstallationList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]ControllerInstallation{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ControllerInstallation", "ControllerInstallation", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ControllerInstallationList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerInstallationSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ControllerInstallationSpec{`,
		`RegistrationRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.RegistrationRef), "ObjectReference", "v1.ObjectReference", 1), `&`, ``, 1) + `,`,
		`SeedRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SeedRef), "ObjectReference", "v1.ObjectReference", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerInstallationStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]Condition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "Condition", "Condition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&ControllerInstallationStatus{`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`ProviderStatus:` + strings.Replace(fmt.Sprintf("%v", this.ProviderStatus), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerRegistration) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ControllerRegistration{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ControllerRegistrationSpec", "ControllerRegistrationSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerRegistrationList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]ControllerRegistration{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ControllerRegistration", "ControllerRegistration", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ControllerRegistrationList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerRegistrationSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForResources := "[]ControllerResource{"
	for _, f := range this.Resources {
		repeatedStringForResources += strings.Replace(strings.Replace(f.String(), "ControllerResource", "ControllerResource", 1), `&`, ``, 1) + ","
	}
	repeatedStringForResources += "}"
	s := strings.Join([]string{`&ControllerRegistrationSpec{`,
		`Resources:` + repeatedStringForResources + `,`,
		`Deployment:` + strings.Replace(this.Deployment.String(), "ControllerDeployment", "ControllerDeployment", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ControllerResource) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ControllerResource{`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`GloballyEnabled:` + valueToStringGenerated(this.GloballyEnabled) + `,`,
		`ReconcileTimeout:` + strings.Replace(fmt.Sprintf("%v", this.ReconcileTimeout), "Duration", "v11.Duration", 1) + `,`,
		`Primary:` + valueToStringGenerated(this.Primary) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DNS) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForProviders := "[]DNSProvider{"
	for _, f := range this.Providers {
		repeatedStringForProviders += strings.Replace(strings.Replace(f.String(), "DNSProvider", "DNSProvider", 1), `&`, ``, 1) + ","
	}
	repeatedStringForProviders += "}"
	s := strings.Join([]string{`&DNS{`,
		`Domain:` + valueToStringGenerated(this.Domain) + `,`,
		`Providers:` + repeatedStringForProviders + `,`,
		`}`,
	}, "")
	return s
}
func (this *DNSIncludeExclude) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DNSIncludeExclude{`,
		`Include:` + fmt.Sprintf("%v", this.Include) + `,`,
		`Exclude:` + fmt.Sprintf("%v", this.Exclude) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DNSProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DNSProvider{`,
		`Domains:` + strings.Replace(this.Domains.String(), "DNSIncludeExclude", "DNSIncludeExclude", 1) + `,`,
		`Primary:` + valueToStringGenerated(this.Primary) + `,`,
		`SecretName:` + valueToStringGenerated(this.SecretName) + `,`,
		`Type:` + valueToStringGenerated(this.Type) + `,`,
		`Zones:` + strings.Replace(this.Zones.String(), "DNSIncludeExclude", "DNSIncludeExclude", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataVolume) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataVolume{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Type:` + valueToStringGenerated(this.Type) + `,`,
		`VolumeSize:` + fmt.Sprintf("%v", this.VolumeSize) + `,`,
		`Encrypted:` + valueToStringGenerated(this.Encrypted) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Endpoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Endpoint{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
		`Purpose:` + fmt.Sprintf("%v", this.Purpose) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExpirableVersion) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExpirableVersion{`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`ExpirationDate:` + strings.Replace(fmt.Sprintf("%v", this.ExpirationDate), "Time", "v11.Time", 1) + `,`,
		`Classification:` + valueToStringGenerated(this.Classification) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Extension) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Extension{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Disabled:` + valueToStringGenerated(this.Disabled) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExtensionResourceState) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForResources := "[]NamedResourceReference{"
	for _, f := range this.Resources {
		repeatedStringForResources += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForResources += "}"
	s := strings.Join([]string{`&ExtensionResourceState{`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`Name:` + valueToStringGenerated(this.Name) + `,`,
		`Purpose:` + valueToStringGenerated(this.Purpose) + `,`,
		`State:` + strings.Replace(fmt.Sprintf("%v", this.State), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Resources:` + repeatedStringForResources + `,`,
		`}`,
	}, "")
	return s
}
func (this *Gardener) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Gardener{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GardenerResourceData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GardenerResourceData{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Data:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Data), "RawExtension", "runtime.RawExtension", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Hibernation) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSchedules := "[]HibernationSchedule{"
	for _, f := range this.Schedules {
		repeatedStringForSchedules += strings.Replace(strings.Replace(f.String(), "HibernationSchedule", "HibernationSchedule", 1), `&`, ``, 1) + ","
	}
	repeatedStringForSchedules += "}"
	s := strings.Join([]string{`&Hibernation{`,
		`Enabled:` + valueToStringGenerated(this.Enabled) + `,`,
		`Schedules:` + repeatedStringForSchedules + `,`,
		`}`,
	}, "")
	return s
}
func (this *HibernationSchedule) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HibernationSchedule{`,
		`Start:` + valueToStringGenerated(this.Start) + `,`,
		`End:` + valueToStringGenerated(this.End) + `,`,
		`Location:` + valueToStringGenerated(this.Location) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HorizontalPodAutoscalerConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HorizontalPodAutoscalerConfig{`,
		`CPUInitializationPeriod:` + strings.Replace(fmt.Sprintf("%v", this.CPUInitializationPeriod), "Duration", "v11.Duration", 1) + `,`,
		`DownscaleDelay:` + strings.Replace(fmt.Sprintf("%v", this.DownscaleDelay), "Duration", "v11.Duration", 1) + `,`,
		`DownscaleStabilization:` + strings.Replace(fmt.Sprintf("%v", this.DownscaleStabilization), "Duration", "v11.Duration", 1) + `,`,
		`InitialReadinessDelay:` + strings.Replace(fmt.Sprintf("%v", this.InitialReadinessDelay), "Duration", "v11.Duration", 1) + `,`,
		`SyncPeriod:` + strings.Replace(fmt.Sprintf("%v", this.SyncPeriod), "Duration", "v11.Duration", 1) + `,`,
		`Tolerance:` + valueToStringGenerated(this.Tolerance) + `,`,
		`UpscaleDelay:` + strings.Replace(fmt.Sprintf("%v", this.UpscaleDelay), "Duration", "v11.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Ingress) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Ingress{`,
		`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
		`Controller:` + strings.Replace(strings.Replace(this.Controller.String(), "IngressController", "IngressController", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IngressController) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IngressController{`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeAPIServerConfig) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAdmissionPlugins := "[]AdmissionPlugin{"
	for _, f := range this.AdmissionPlugins {
		repeatedStringForAdmissionPlugins += strings.Replace(strings.Replace(f.String(), "AdmissionPlugin", "AdmissionPlugin", 1), `&`, ``, 1) + ","
	}
	repeatedStringForAdmissionPlugins += "}"
	keysForRuntimeConfig := make([]string, 0, len(this.RuntimeConfig))
	for k := range this.RuntimeConfig {
		keysForRuntimeConfig = append(keysForRuntimeConfig, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRuntimeConfig)
	mapStringForRuntimeConfig := "map[string]bool{"
	for _, k := range keysForRuntimeConfig {
		mapStringForRuntimeConfig += fmt.Sprintf("%v: %v,", k, this.RuntimeConfig[k])
	}
	mapStringForRuntimeConfig += "}"
	s := strings.Join([]string{`&KubeAPIServerConfig{`,
		`KubernetesConfig:` + strings.Replace(strings.Replace(this.KubernetesConfig.String(), "KubernetesConfig", "KubernetesConfig", 1), `&`, ``, 1) + `,`,
		`AdmissionPlugins:` + repeatedStringForAdmissionPlugins + `,`,
		`APIAudiences:` + fmt.Sprintf("%v", this.APIAudiences) + `,`,
		`AuditConfig:` + strings.Replace(this.AuditConfig.String(), "AuditConfig", "AuditConfig", 1) + `,`,
		`EnableBasicAuthentication:` + valueToStringGenerated(this.EnableBasicAuthentication) + `,`,
		`OIDCConfig:` + strings.Replace(this.OIDCConfig.String(), "OIDCConfig", "OIDCConfig", 1) + `,`,
		`RuntimeConfig:` + mapStringForRuntimeConfig + `,`,
		`ServiceAccountConfig:` + strings.Replace(this.ServiceAccountConfig.String(), "ServiceAccountConfig", "ServiceAccountConfig", 1) + `,`,
		`WatchCacheSizes:` + strings.Replace(this.WatchCacheSizes.String(), "WatchCacheSizes", "WatchCacheSizes", 1) + `,`,
		`Requests:` + strings.Replace(this.Requests.String(), "KubeAPIServerRequests", "KubeAPIServerRequests", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeAPIServerRequests) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeAPIServerRequests{`,
		`MaxNonMutatingInflight:` + valueToStringGenerated(this.MaxNonMutatingInflight) + `,`,
		`MaxMutatingInflight:` + valueToStringGenerated(this.MaxMutatingInflight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeControllerManagerConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeControllerManagerConfig{`,
		`KubernetesConfig:` + strings.Replace(strings.Replace(this.KubernetesConfig.String(), "KubernetesConfig", "KubernetesConfig", 1), `&`, ``, 1) + `,`,
		`HorizontalPodAutoscalerConfig:` + strings.Replace(this.HorizontalPodAutoscalerConfig.String(), "HorizontalPodAutoscalerConfig", "HorizontalPodAutoscalerConfig", 1) + `,`,
		`NodeCIDRMaskSize:` + valueToStringGenerated(this.NodeCIDRMaskSize) + `,`,
		`PodEvictionTimeout:` + strings.Replace(fmt.Sprintf("%v", this.PodEvictionTimeout), "Duration", "v11.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeProxyConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeProxyConfig{`,
		`KubernetesConfig:` + strings.Replace(strings.Replace(this.KubernetesConfig.String(), "KubernetesConfig", "KubernetesConfig", 1), `&`, ``, 1) + `,`,
		`Mode:` + valueToStringGenerated(this.Mode) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeSchedulerConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeSchedulerConfig{`,
		`KubernetesConfig:` + strings.Replace(strings.Replace(this.KubernetesConfig.String(), "KubernetesConfig", "KubernetesConfig", 1), `&`, ``, 1) + `,`,
		`KubeMaxPDVols:` + valueToStringGenerated(this.KubeMaxPDVols) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeletConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeletConfig{`,
		`KubernetesConfig:` + strings.Replace(strings.Replace(this.KubernetesConfig.String(), "KubernetesConfig", "KubernetesConfig", 1), `&`, ``, 1) + `,`,
		`CPUCFSQuota:` + valueToStringGenerated(this.CPUCFSQuota) + `,`,
		`CPUManagerPolicy:` + valueToStringGenerated(this.CPUManagerPolicy) + `,`,
		`EvictionHard:` + strings.Replace(this.EvictionHard.String(), "KubeletConfigEviction", "KubeletConfigEviction", 1) + `,`,
		`EvictionMaxPodGracePeriod:` + valueToStringGenerated(this.EvictionMaxPodGracePeriod) + `,`,
		`EvictionMinimumReclaim:` + strings.Replace(this.EvictionMinimumReclaim.String(), "KubeletConfigEvictionMinimumReclaim", "KubeletConfigEvictionMinimumReclaim", 1) + `,`,
		`EvictionPressureTransitionPeriod:` + strings.Replace(fmt.Sprintf("%v", this.EvictionPressureTransitionPeriod), "Duration", "v11.Duration", 1) + `,`,
		`EvictionSoft:` + strings.Replace(this.EvictionSoft.String(), "KubeletConfigEviction", "KubeletConfigEviction", 1) + `,`,
		`EvictionSoftGracePeriod:` + strings.Replace(this.EvictionSoftGracePeriod.String(), "KubeletConfigEvictionSoftGracePeriod", "KubeletConfigEvictionSoftGracePeriod", 1) + `,`,
		`MaxPods:` + valueToStringGenerated(this.MaxPods) + `,`,
		`PodPIDsLimit:` + valueToStringGenerated(this.PodPIDsLimit) + `,`,
		`ImagePullProgressDeadline:` + strings.Replace(fmt.Sprintf("%v", this.ImagePullProgressDeadline), "Duration", "v11.Duration", 1) + `,`,
		`FailSwapOn:` + valueToStringGenerated(this.FailSwapOn) + `,`,
		`KubeReserved:` + strings.Replace(this.KubeReserved.String(), "KubeletConfigReserved", "KubeletConfigReserved", 1) + `,`,
		`SystemReserved:` + strings.Replace(this.SystemReserved.String(), "KubeletConfigReserved", "KubeletConfigReserved", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeletConfigEviction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeletConfigEviction{`,
		`MemoryAvailable:` + valueToStringGenerated(this.MemoryAvailable) + `,`,
		`ImageFSAvailable:` + valueToStringGenerated(this.ImageFSAvailable) + `,`,
		`ImageFSInodesFree:` + valueToStringGenerated(this.ImageFSInodesFree) + `,`,
		`NodeFSAvailable:` + valueToStringGenerated(this.NodeFSAvailable) + `,`,
		`NodeFSInodesFree:` + valueToStringGenerated(this.NodeFSInodesFree) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeletConfigEvictionMinimumReclaim) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeletConfigEvictionMinimumReclaim{`,
		`MemoryAvailable:` + strings.Replace(fmt.Sprintf("%v", this.MemoryAvailable), "Quantity", "resource.Quantity", 1) + `,`,
		`ImageFSAvailable:` + strings.Replace(fmt.Sprintf("%v", this.ImageFSAvailable), "Quantity", "resource.Quantity", 1) + `,`,
		`ImageFSInodesFree:` + strings.Replace(fmt.Sprintf("%v", this.ImageFSInodesFree), "Quantity", "resource.Quantity", 1) + `,`,
		`NodeFSAvailable:` + strings.Replace(fmt.Sprintf("%v", this.NodeFSAvailable), "Quantity", "resource.Quantity", 1) + `,`,
		`NodeFSInodesFree:` + strings.Replace(fmt.Sprintf("%v", this.NodeFSInodesFree), "Quantity", "resource.Quantity", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeletConfigEvictionSoftGracePeriod) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeletConfigEvictionSoftGracePeriod{`,
		`MemoryAvailable:` + strings.Replace(fmt.Sprintf("%v", this.MemoryAvailable), "Duration", "v11.Duration", 1) + `,`,
		`ImageFSAvailable:` + strings.Replace(fmt.Sprintf("%v", this.ImageFSAvailable), "Duration", "v11.Duration", 1) + `,`,
		`ImageFSInodesFree:` + strings.Replace(fmt.Sprintf("%v", this.ImageFSInodesFree), "Duration", "v11.Duration", 1) + `,`,
		`NodeFSAvailable:` + strings.Replace(fmt.Sprintf("%v", this.NodeFSAvailable), "Duration", "v11.Duration", 1) + `,`,
		`NodeFSInodesFree:` + strings.Replace(fmt.Sprintf("%v", this.NodeFSInodesFree), "Duration", "v11.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubeletConfigReserved) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubeletConfigReserved{`,
		`CPU:` + strings.Replace(fmt.Sprintf("%v", this.CPU), "Quantity", "resource.Quantity", 1) + `,`,
		`Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "Quantity", "resource.Quantity", 1) + `,`,
		`EphemeralStorage:` + strings.Replace(fmt.Sprintf("%v", this.EphemeralStorage), "Quantity", "resource.Quantity", 1) + `,`,
		`PID:` + strings.Replace(fmt.Sprintf("%v", this.PID), "Quantity", "resource.Quantity", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Kubernetes) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Kubernetes{`,
		`AllowPrivilegedContainers:` + valueToStringGenerated(this.AllowPrivilegedContainers) + `,`,
		`ClusterAutoscaler:` + strings.Replace(this.ClusterAutoscaler.String(), "ClusterAutoscaler", "ClusterAutoscaler", 1) + `,`,
		`KubeAPIServer:` + strings.Replace(this.KubeAPIServer.String(), "KubeAPIServerConfig", "KubeAPIServerConfig", 1) + `,`,
		`KubeControllerManager:` + strings.Replace(this.KubeControllerManager.String(), "KubeControllerManagerConfig", "KubeControllerManagerConfig", 1) + `,`,
		`KubeScheduler:` + strings.Replace(this.KubeScheduler.String(), "KubeSchedulerConfig", "KubeSchedulerConfig", 1) + `,`,
		`KubeProxy:` + strings.Replace(this.KubeProxy.String(), "KubeProxyConfig", "KubeProxyConfig", 1) + `,`,
		`Kubelet:` + strings.Replace(this.Kubelet.String(), "KubeletConfig", "KubeletConfig", 1) + `,`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`VerticalPodAutoscaler:` + strings.Replace(this.VerticalPodAutoscaler.String(), "VerticalPodAutoscaler", "VerticalPodAutoscaler", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubernetesConfig) String() string {
	if this == nil {
		return "nil"
	}
	keysForFeatureGates := make([]string, 0, len(this.FeatureGates))
	for k := range this.FeatureGates {
		keysForFeatureGates = append(keysForFeatureGates, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForFeatureGates)
	mapStringForFeatureGates := "map[string]bool{"
	for _, k := range keysForFeatureGates {
		mapStringForFeatureGates += fmt.Sprintf("%v: %v,", k, this.FeatureGates[k])
	}
	mapStringForFeatureGates += "}"
	s := strings.Join([]string{`&KubernetesConfig{`,
		`FeatureGates:` + mapStringForFeatureGates + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubernetesDashboard) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubernetesDashboard{`,
		`AuthenticationMode:` + valueToStringGenerated(this.AuthenticationMode) + `,`,
		`Addon:` + strings.Replace(strings.Replace(this.Addon.String(), "Addon", "Addon", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubernetesInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&KubernetesInfo{`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`}`,
	}, "")
	return s
}
func (this *KubernetesSettings) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVersions := "[]ExpirableVersion{"
	for _, f := range this.Versions {
		repeatedStringForVersions += strings.Replace(strings.Replace(f.String(), "ExpirableVersion", "ExpirableVersion", 1), `&`, ``, 1) + ","
	}
	repeatedStringForVersions += "}"
	s := strings.Join([]string{`&KubernetesSettings{`,
		`Versions:` + repeatedStringForVersions + `,`,
		`}`,
	}, "")
	return s
}
func (this *LastError) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LastError{`,
		`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
		`TaskID:` + valueToStringGenerated(this.TaskID) + `,`,
		`Codes:` + fmt.Sprintf("%v", this.Codes) + `,`,
		`LastUpdateTime:` + strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v11.Time", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LastOperation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LastOperation{`,
		`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
		`LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v11.Time", 1), `&`, ``, 1) + `,`,
		`Progress:` + fmt.Sprintf("%v", this.Progress) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Machine) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Machine{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Image:` + strings.Replace(this.Image.String(), "ShootMachineImage", "ShootMachineImage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MachineControllerManagerSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MachineControllerManagerSettings{`,
		`MachineDrainTimeout:` + strings.Replace(fmt.Sprintf("%v", this.MachineDrainTimeout), "Duration", "v11.Duration", 1) + `,`,
		`MachineHealthTimeout:` + strings.Replace(fmt.Sprintf("%v", this.MachineHealthTimeout), "Duration", "v11.Duration", 1) + `,`,
		`MachineCreationTimeout:` + strings.Replace(fmt.Sprintf("%v", this.MachineCreationTimeout), "Duration", "v11.Duration", 1) + `,`,
		`MaxEvictRetries:` + valueToStringGenerated(this.MaxEvictRetries) + `,`,
		`NodeConditions:` + fmt.Sprintf("%v", this.NodeConditions) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MachineImage) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVersions := "[]MachineImageVersion{"
	for _, f := range this.Versions {
		repeatedStringForVersions += strings.Replace(strings.Replace(f.String(), "MachineImageVersion", "MachineImageVersion", 1), `&`, ``, 1) + ","
	}
	repeatedStringForVersions += "}"
	s := strings.Join([]string{`&MachineImage{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Versions:` + repeatedStringForVersions + `,`,
		`}`,
	}, "")
	return s
}
func (this *MachineImageVersion) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForCRI := "[]CRI{"
	for _, f := range this.CRI {
		repeatedStringForCRI += strings.Replace(strings.Replace(f.String(), "CRI", "CRI", 1), `&`, ``, 1) + ","
	}
	repeatedStringForCRI += "}"
	s := strings.Join([]string{`&MachineImageVersion{`,
		`ExpirableVersion:` + strings.Replace(strings.Replace(this.ExpirableVersion.String(), "ExpirableVersion", "ExpirableVersion", 1), `&`, ``, 1) + `,`,
		`CRI:` + repeatedStringForCRI + `,`,
		`}`,
	}, "")
	return s
}
func (this *MachineType) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MachineType{`,
		`CPU:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CPU), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
		`GPU:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GPU), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
		`Memory:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Memory), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Storage:` + strings.Replace(this.Storage.String(), "MachineTypeStorage", "MachineTypeStorage", 1) + `,`,
		`Usable:` + valueToStringGenerated(this.Usable) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MachineTypeStorage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MachineTypeStorage{`,
		`Class:` + fmt.Sprintf("%v", this.Class) + `,`,
		`StorageSize:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StorageSize), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Maintenance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Maintenance{`,
		`AutoUpdate:` + strings.Replace(this.AutoUpdate.String(), "MaintenanceAutoUpdate", "MaintenanceAutoUpdate", 1) + `,`,
		`TimeWindow:` + strings.Replace(this.TimeWindow.String(), "MaintenanceTimeWindow", "MaintenanceTimeWindow", 1) + `,`,
		`ConfineSpecUpdateRollout:` + valueToStringGenerated(this.ConfineSpecUpdateRollout) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MaintenanceAutoUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MaintenanceAutoUpdate{`,
		`KubernetesVersion:` + fmt.Sprintf("%v", this.KubernetesVersion) + `,`,
		`MachineImageVersion:` + fmt.Sprintf("%v", this.MachineImageVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MaintenanceTimeWindow) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MaintenanceTimeWindow{`,
		`Begin:` + fmt.Sprintf("%v", this.Begin) + `,`,
		`End:` + fmt.Sprintf("%v", this.End) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Monitoring) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Monitoring{`,
		`Alerting:` + strings.Replace(this.Alerting.String(), "Alerting", "Alerting", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NamedResourceReference) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NamedResourceReference{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ResourceRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ResourceRef), "CrossVersionObjectReference", "v12.CrossVersionObjectReference", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Networking) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Networking{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Pods:` + valueToStringGenerated(this.Pods) + `,`,
		`Nodes:` + valueToStringGenerated(this.Nodes) + `,`,
		`Services:` + valueToStringGenerated(this.Services) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NginxIngress) String() string {
	if this == nil {
		return "nil"
	}
	keysForConfig := make([]string, 0, len(this.Config))
	for k := range this.Config {
		keysForConfig = append(keysForConfig, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForConfig)
	mapStringForConfig := "map[string]string{"
	for _, k := range keysForConfig {
		mapStringForConfig += fmt.Sprintf("%v: %v,", k, this.Config[k])
	}
	mapStringForConfig += "}"
	s := strings.Join([]string{`&NginxIngress{`,
		`LoadBalancerSourceRanges:` + fmt.Sprintf("%v", this.LoadBalancerSourceRanges) + `,`,
		`Config:` + mapStringForConfig + `,`,
		`ExternalTrafficPolicy:` + valueToStringGenerated(this.ExternalTrafficPolicy) + `,`,
		`Addon:` + strings.Replace(strings.Replace(this.Addon.String(), "Addon", "Addon", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OIDCConfig) String() string {
	if this == nil {
		return "nil"
	}
	keysForRequiredClaims := make([]string, 0, len(this.RequiredClaims))
	for k := range this.RequiredClaims {
		keysForRequiredClaims = append(keysForRequiredClaims, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRequiredClaims)
	mapStringForRequiredClaims := "map[string]string{"
	for _, k := range keysForRequiredClaims {
		mapStringForRequiredClaims += fmt.Sprintf("%v: %v,", k, this.RequiredClaims[k])
	}
	mapStringForRequiredClaims += "}"
	s := strings.Join([]string{`&OIDCConfig{`,
		`CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
		`ClientAuthentication:` + strings.Replace(this.ClientAuthentication.String(), "OpenIDConnectClientAuthentication", "OpenIDConnectClientAuthentication", 1) + `,`,
		`ClientID:` + valueToStringGenerated(this.ClientID) + `,`,
		`GroupsClaim:` + valueToStringGenerated(this.GroupsClaim) + `,`,
		`GroupsPrefix:` + valueToStringGenerated(this.GroupsPrefix) + `,`,
		`IssuerURL:` + valueToStringGenerated(this.IssuerURL) + `,`,
		`RequiredClaims:` + mapStringForRequiredClaims + `,`,
		`SigningAlgs:` + fmt.Sprintf("%v", this.SigningAlgs) + `,`,
		`UsernameClaim:` + valueToStringGenerated(this.UsernameClaim) + `,`,
		`UsernamePrefix:` + valueToStringGenerated(this.UsernamePrefix) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OpenIDConnectClientAuthentication) String() string {
	if this == nil {
		return "nil"
	}
	keysForExtraConfig := make([]string, 0, len(this.ExtraConfig))
	for k := range this.ExtraConfig {
		keysForExtraConfig = append(keysForExtraConfig, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForExtraConfig)
	mapStringForExtraConfig := "map[string]string{"
	for _, k := range keysForExtraConfig {
		mapStringForExtraConfig += fmt.Sprintf("%v: %v,", k, this.ExtraConfig[k])
	}
	mapStringForExtraConfig += "}"
	s := strings.Join([]string{`&OpenIDConnectClientAuthentication{`,
		`ExtraConfig:` + mapStringForExtraConfig + `,`,
		`Secret:` + valueToStringGenerated(this.Secret) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Plant) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Plant{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PlantSpec", "PlantSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "PlantStatus", "PlantStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PlantList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Plant{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Plant", "Plant", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&PlantList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *PlantSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEndpoints := "[]Endpoint{"
	for _, f := range this.Endpoints {
		repeatedStringForEndpoints += strings.Replace(strings.Replace(f.String(), "Endpoint", "Endpoint", 1), `&`, ``, 1) + ","
	}
	repeatedStringForEndpoints += "}"
	s := strings.Join([]string{`&PlantSpec{`,
		`SecretRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretRef), "LocalObjectReference", "v1.LocalObjectReference", 1), `&`, ``, 1) + `,`,
		`Endpoints:` + repeatedStringForEndpoints + `,`,
		`}`,
	}, "")
	return s
}
func (this *PlantStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]Condition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "Condition", "Condition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&PlantStatus{`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`,
		`ClusterInfo:` + strings.Replace(this.ClusterInfo.String(), "ClusterInfo", "ClusterInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Project) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Project{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ProjectSpec", "ProjectSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ProjectStatus", "ProjectStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProjectList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Project{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Project", "Project", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ProjectList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProjectMember) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProjectMember{`,
		`Subject:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Subject), "Subject", "v13.Subject", 1), `&`, ``, 1) + `,`,
		`Role:` + fmt.Sprintf("%v", this.Role) + `,`,
		`Roles:` + fmt.Sprintf("%v", this.Roles) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProjectSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMembers := "[]ProjectMember{"
	for _, f := range this.Members {
		repeatedStringForMembers += strings.Replace(strings.Replace(f.String(), "ProjectMember", "ProjectMember", 1), `&`, ``, 1) + ","
	}
	repeatedStringForMembers += "}"
	s := strings.Join([]string{`&ProjectSpec{`,
		`CreatedBy:` + strings.Replace(fmt.Sprintf("%v", this.CreatedBy), "Subject", "v13.Subject", 1) + `,`,
		`Description:` + valueToStringGenerated(this.Description) + `,`,
		`Owner:` + strings.Replace(fmt.Sprintf("%v", this.Owner), "Subject", "v13.Subject", 1) + `,`,
		`Purpose:` + valueToStringGenerated(this.Purpose) + `,`,
		`Members:` + repeatedStringForMembers + `,`,
		`Namespace:` + valueToStringGenerated(this.Namespace) + `,`,
		`Tolerations:` + strings.Replace(this.Tolerations.String(), "ProjectTolerations", "ProjectTolerations", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProjectStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProjectStatus{`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`StaleSinceTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.StaleSinceTimestamp), "Time", "v11.Time", 1) + `,`,
		`StaleAutoDeleteTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.StaleAutoDeleteTimestamp), "Time", "v11.Time", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProjectTolerations) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForDefaults := "[]Toleration{"
	for _, f := range this.Defaults {
		repeatedStringForDefaults += strings.Replace(strings.Replace(f.String(), "Toleration", "Toleration", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDefaults += "}"
	repeatedStringForWhitelist := "[]Toleration{"
	for _, f := range this.Whitelist {
		repeatedStringForWhitelist += strings.Replace(strings.Replace(f.String(), "Toleration", "Toleration", 1), `&`, ``, 1) + ","
	}
	repeatedStringForWhitelist += "}"
	s := strings.Join([]string{`&ProjectTolerations{`,
		`Defaults:` + repeatedStringForDefaults + `,`,
		`Whitelist:` + repeatedStringForWhitelist + `,`,
		`}`,
	}, "")
	return s
}
func (this *Provider) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForWorkers := "[]Worker{"
	for _, f := range this.Workers {
		repeatedStringForWorkers += strings.Replace(strings.Replace(f.String(), "Worker", "Worker", 1), `&`, ``, 1) + ","
	}
	repeatedStringForWorkers += "}"
	s := strings.Join([]string{`&Provider{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ControlPlaneConfig:` + strings.Replace(fmt.Sprintf("%v", this.ControlPlaneConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`InfrastructureConfig:` + strings.Replace(fmt.Sprintf("%v", this.InfrastructureConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Workers:` + repeatedStringForWorkers + `,`,
		`}`,
	}, "")
	return s
}
func (this *Quota) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Quota{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "QuotaSpec", "QuotaSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QuotaList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Quota{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Quota", "Quota", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&QuotaList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *QuotaSpec) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetrics := make([]string, 0, len(this.Metrics))
	for k := range this.Metrics {
		keysForMetrics = append(keysForMetrics, string(k))
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetrics)
	mapStringForMetrics := "k8s_io_api_core_v1.ResourceList{"
	for _, k := range keysForMetrics {
		mapStringForMetrics += fmt.Sprintf("%v: %v,", k, this.Metrics[k8s_io_api_core_v1.ResourceName(k)])
	}
	mapStringForMetrics += "}"
	s := strings.Join([]string{`&QuotaSpec{`,
		`ClusterLifetimeDays:` + valueToStringGenerated(this.ClusterLifetimeDays) + `,`,
		`Metrics:` + mapStringForMetrics + `,`,
		`Scope:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Scope), "ObjectReference", "v1.ObjectReference", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Region) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForZones := "[]AvailabilityZone{"
	for _, f := range this.Zones {
		repeatedStringForZones += strings.Replace(strings.Replace(f.String(), "AvailabilityZone", "AvailabilityZone", 1), `&`, ``, 1) + ","
	}
	repeatedStringForZones += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	s := strings.Join([]string{`&Region{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Zones:` + repeatedStringForZones + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceData{`,
		`CrossVersionObjectReference:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CrossVersionObjectReference), "CrossVersionObjectReference", "v12.CrossVersionObjectReference", 1), `&`, ``, 1) + `,`,
		`Data:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Data), "RawExtension", "runtime.RawExtension", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceWatchCacheSize) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceWatchCacheSize{`,
		`APIGroup:` + valueToStringGenerated(this.APIGroup) + `,`,
		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
		`CacheSize:` + fmt.Sprintf("%v", this.CacheSize) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SecretBinding) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForQuotas := "[]ObjectReference{"
	for _, f := range this.Quotas {
		repeatedStringForQuotas += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForQuotas += "}"
	s := strings.Join([]string{`&SecretBinding{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`SecretRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretRef), "SecretReference", "v1.SecretReference", 1), `&`, ``, 1) + `,`,
		`Quotas:` + repeatedStringForQuotas + `,`,
		`}`,
	}, "")
	return s
}
func (this *SecretBindingList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]SecretBinding{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "SecretBinding", "SecretBinding", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&SecretBindingList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *Seed) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Seed{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SeedSpec", "SeedSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "SeedStatus", "SeedStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedBackup) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedBackup{`,
		`Provider:` + fmt.Sprintf("%v", this.Provider) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Region:` + valueToStringGenerated(this.Region) + `,`,
		`SecretRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretRef), "SecretReference", "v1.SecretReference", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedDNS) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedDNS{`,
		`IngressDomain:` + valueToStringGenerated(this.IngressDomain) + `,`,
		`Provider:` + strings.Replace(this.Provider.String(), "SeedDNSProvider", "SeedDNSProvider", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedDNSProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedDNSProvider{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`SecretRef:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SecretRef), "SecretReference", "v1.SecretReference", 1), `&`, ``, 1) + `,`,
		`Domains:` + strings.Replace(this.Domains.String(), "DNSIncludeExclude", "DNSIncludeExclude", 1) + `,`,
		`Zones:` + strings.Replace(this.Zones.String(), "DNSIncludeExclude", "DNSIncludeExclude", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Seed{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Seed", "Seed", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&SeedList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedNetworks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedNetworks{`,
		`Nodes:` + valueToStringGenerated(this.Nodes) + `,`,
		`Pods:` + fmt.Sprintf("%v", this.Pods) + `,`,
		`Services:` + fmt.Sprintf("%v", this.Services) + `,`,
		`ShootDefaults:` + strings.Replace(this.ShootDefaults.String(), "ShootNetworks", "ShootNetworks", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedProvider{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSelector) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSelector{`,
		`LabelSelector:` + strings.Replace(fmt.Sprintf("%v", this.LabelSelector), "LabelSelector", "v11.LabelSelector", 1) + `,`,
		`ProviderTypes:` + fmt.Sprintf("%v", this.ProviderTypes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettingExcessCapacityReservation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSettingExcessCapacityReservation{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettingLoadBalancerServices) String() string {
	if this == nil {
		return "nil"
	}
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	s := strings.Join([]string{`&SeedSettingLoadBalancerServices{`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettingScheduling) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSettingScheduling{`,
		`Visible:` + fmt.Sprintf("%v", this.Visible) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettingShootDNS) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSettingShootDNS{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettingVerticalPodAutoscaler) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSettingVerticalPodAutoscaler{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSettings) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedSettings{`,
		`ExcessCapacityReservation:` + strings.Replace(this.ExcessCapacityReservation.String(), "SeedSettingExcessCapacityReservation", "SeedSettingExcessCapacityReservation", 1) + `,`,
		`Scheduling:` + strings.Replace(this.Scheduling.String(), "SeedSettingScheduling", "SeedSettingScheduling", 1) + `,`,
		`ShootDNS:` + strings.Replace(this.ShootDNS.String(), "SeedSettingShootDNS", "SeedSettingShootDNS", 1) + `,`,
		`LoadBalancerServices:` + strings.Replace(this.LoadBalancerServices.String(), "SeedSettingLoadBalancerServices", "SeedSettingLoadBalancerServices", 1) + `,`,
		`VerticalPodAutoscaler:` + strings.Replace(this.VerticalPodAutoscaler.String(), "SeedSettingVerticalPodAutoscaler", "SeedSettingVerticalPodAutoscaler", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTaints := "[]SeedTaint{"
	for _, f := range this.Taints {
		repeatedStringForTaints += strings.Replace(strings.Replace(f.String(), "SeedTaint", "SeedTaint", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTaints += "}"
	s := strings.Join([]string{`&SeedSpec{`,
		`Backup:` + strings.Replace(this.Backup.String(), "SeedBackup", "SeedBackup", 1) + `,`,
		`BlockCIDRs:` + fmt.Sprintf("%v", this.BlockCIDRs) + `,`,
		`DNS:` + strings.Replace(strings.Replace(this.DNS.String(), "SeedDNS", "SeedDNS", 1), `&`, ``, 1) + `,`,
		`Networks:` + strings.Replace(strings.Replace(this.Networks.String(), "SeedNetworks", "SeedNetworks", 1), `&`, ``, 1) + `,`,
		`Provider:` + strings.Replace(strings.Replace(this.Provider.String(), "SeedProvider", "SeedProvider", 1), `&`, ``, 1) + `,`,
		`SecretRef:` + strings.Replace(fmt.Sprintf("%v", this.SecretRef), "SecretReference", "v1.SecretReference", 1) + `,`,
		`Taints:` + repeatedStringForTaints + `,`,
		`Volume:` + strings.Replace(this.Volume.String(), "SeedVolume", "SeedVolume", 1) + `,`,
		`Settings:` + strings.Replace(this.Settings.String(), "SeedSettings", "SeedSettings", 1) + `,`,
		`Ingress:` + strings.Replace(this.Ingress.String(), "Ingress", "Ingress", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]Condition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "Condition", "Condition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&SeedStatus{`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`Gardener:` + strings.Replace(this.Gardener.String(), "Gardener", "Gardener", 1) + `,`,
		`KubernetesVersion:` + valueToStringGenerated(this.KubernetesVersion) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`ClusterIdentity:` + valueToStringGenerated(this.ClusterIdentity) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedTaint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedTaint{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + valueToStringGenerated(this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedVolume) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForProviders := "[]SeedVolumeProvider{"
	for _, f := range this.Providers {
		repeatedStringForProviders += strings.Replace(strings.Replace(f.String(), "SeedVolumeProvider", "SeedVolumeProvider", 1), `&`, ``, 1) + ","
	}
	repeatedStringForProviders += "}"
	s := strings.Join([]string{`&SeedVolume{`,
		`MinimumSize:` + strings.Replace(fmt.Sprintf("%v", this.MinimumSize), "Quantity", "resource.Quantity", 1) + `,`,
		`Providers:` + repeatedStringForProviders + `,`,
		`}`,
	}, "")
	return s
}
func (this *SeedVolumeProvider) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SeedVolumeProvider{`,
		`Purpose:` + fmt.Sprintf("%v", this.Purpose) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServiceAccountConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServiceAccountConfig{`,
		`Issuer:` + valueToStringGenerated(this.Issuer) + `,`,
		`SigningKeySecret:` + strings.Replace(fmt.Sprintf("%v", this.SigningKeySecret), "LocalObjectReference", "v1.LocalObjectReference", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Shoot) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Shoot{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ShootSpec", "ShootSpec", 1), `&`, ``, 1) + `,`,
		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ShootStatus", "ShootStatus", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]Shoot{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Shoot", "Shoot", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ShootList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootMachineImage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShootMachineImage{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Version:` + valueToStringGenerated(this.Version) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootNetworks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShootNetworks{`,
		`Pods:` + valueToStringGenerated(this.Pods) + `,`,
		`Services:` + valueToStringGenerated(this.Services) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForExtensions := "[]Extension{"
	for _, f := range this.Extensions {
		repeatedStringForExtensions += strings.Replace(strings.Replace(f.String(), "Extension", "Extension", 1), `&`, ``, 1) + ","
	}
	repeatedStringForExtensions += "}"
	repeatedStringForResources := "[]NamedResourceReference{"
	for _, f := range this.Resources {
		repeatedStringForResources += strings.Replace(strings.Replace(f.String(), "NamedResourceReference", "NamedResourceReference", 1), `&`, ``, 1) + ","
	}
	repeatedStringForResources += "}"
	repeatedStringForTolerations := "[]Toleration{"
	for _, f := range this.Tolerations {
		repeatedStringForTolerations += strings.Replace(strings.Replace(f.String(), "Toleration", "Toleration", 1), `&`, ``, 1) + ","
	}
	repeatedStringForTolerations += "}"
	s := strings.Join([]string{`&ShootSpec{`,
		`Addons:` + strings.Replace(this.Addons.String(), "Addons", "Addons", 1) + `,`,
		`CloudProfileName:` + fmt.Sprintf("%v", this.CloudProfileName) + `,`,
		`DNS:` + strings.Replace(this.DNS.String(), "DNS", "DNS", 1) + `,`,
		`Extensions:` + repeatedStringForExtensions + `,`,
		`Hibernation:` + strings.Replace(this.Hibernation.String(), "Hibernation", "Hibernation", 1) + `,`,
		`Kubernetes:` + strings.Replace(strings.Replace(this.Kubernetes.String(), "Kubernetes", "Kubernetes", 1), `&`, ``, 1) + `,`,
		`Networking:` + strings.Replace(strings.Replace(this.Networking.String(), "Networking", "Networking", 1), `&`, ``, 1) + `,`,
		`Maintenance:` + strings.Replace(this.Maintenance.String(), "Maintenance", "Maintenance", 1) + `,`,
		`Monitoring:` + strings.Replace(this.Monitoring.String(), "Monitoring", "Monitoring", 1) + `,`,
		`Provider:` + strings.Replace(strings.Replace(this.Provider.String(), "Provider", "Provider", 1), `&`, ``, 1) + `,`,
		`Purpose:` + valueToStringGenerated(this.Purpose) + `,`,
		`Region:` + fmt.Sprintf("%v", this.Region) + `,`,
		`SecretBindingName:` + fmt.Sprintf("%v", this.SecretBindingName) + `,`,
		`SeedName:` + valueToStringGenerated(this.SeedName) + `,`,
		`SeedSelector:` + strings.Replace(this.SeedSelector.String(), "SeedSelector", "SeedSelector", 1) + `,`,
		`Resources:` + repeatedStringForResources + `,`,
		`Tolerations:` + repeatedStringForTolerations + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ShootState{`,
		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`,
		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ShootStateSpec", "ShootStateSpec", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootStateList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForItems := "[]ShootState{"
	for _, f := range this.Items {
		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ShootState", "ShootState", 1), `&`, ``, 1) + ","
	}
	repeatedStringForItems += "}"
	s := strings.Join([]string{`&ShootStateList{`,
		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`,
		`Items:` + repeatedStringForItems + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootStateSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForGardener := "[]GardenerResourceData{"
	for _, f := range this.Gardener {
		repeatedStringForGardener += strings.Replace(strings.Replace(f.String(), "GardenerResourceData", "GardenerResourceData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForGardener += "}"
	repeatedStringForExtensions := "[]ExtensionResourceState{"
	for _, f := range this.Extensions {
		repeatedStringForExtensions += strings.Replace(strings.Replace(f.String(), "ExtensionResourceState", "ExtensionResourceState", 1), `&`, ``, 1) + ","
	}
	repeatedStringForExtensions += "}"
	repeatedStringForResources := "[]ResourceData{"
	for _, f := range this.Resources {
		repeatedStringForResources += strings.Replace(strings.Replace(f.String(), "ResourceData", "ResourceData", 1), `&`, ``, 1) + ","
	}
	repeatedStringForResources += "}"
	s := strings.Join([]string{`&ShootStateSpec{`,
		`Gardener:` + repeatedStringForGardener + `,`,
		`Extensions:` + repeatedStringForExtensions + `,`,
		`Resources:` + repeatedStringForResources + `,`,
		`}`,
	}, "")
	return s
}
func (this *ShootStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]Condition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "Condition", "Condition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForConstraints := "[]Condition{"
	for _, f := range this.Constraints {
		repeatedStringForConstraints += strings.Replace(strings.Replace(f.String(), "Condition", "Condition", 1), `&`, ``, 1) + ","
	}
	repeatedStringForConstraints += "}"
	repeatedStringForLastErrors := "[]LastError{"
	for _, f := range this.LastErrors {
		repeatedStringForLastErrors += strings.Replace(strings.Replace(f.String(), "LastError", "LastError", 1), `&`, ``, 1) + ","
	}
	repeatedStringForLastErrors += "}"
	s := strings.Join([]string{`&ShootStatus{`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`Constraints:` + repeatedStringForConstraints + `,`,
		`Gardener:` + strings.Replace(strings.Replace(this.Gardener.String(), "Gardener", "Gardener", 1), `&`, ``, 1) + `,`,
		`IsHibernated:` + fmt.Sprintf("%v", this.IsHibernated) + `,`,
		`LastOperation:` + strings.Replace(this.LastOperation.String(), "LastOperation", "LastOperation", 1) + `,`,
		`LastError:` + strings.Replace(this.LastError.String(), "LastError", "LastError", 1) + `,`,
		`LastErrors:` + repeatedStringForLastErrors + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`RetryCycleStartTime:` + strings.Replace(fmt.Sprintf("%v", this.RetryCycleStartTime), "Time", "v11.Time", 1) + `,`,
		`Seed:` + valueToStringGenerated(this.Seed) + `,`,
		`TechnicalID:` + fmt.Sprintf("%v", this.TechnicalID) + `,`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`ClusterIdentity:` + valueToStringGenerated(this.ClusterIdentity) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Toleration) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Toleration{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + valueToStringGenerated(this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VerticalPodAutoscaler) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VerticalPodAutoscaler{`,
		`Enabled:` + fmt.Sprintf("%v", this.Enabled) + `,`,
		`EvictAfterOOMThreshold:` + strings.Replace(fmt.Sprintf("%v", this.EvictAfterOOMThreshold), "Duration", "v11.Duration", 1) + `,`,
		`EvictionRateBurst:` + valueToStringGenerated(this.EvictionRateBurst) + `,`,
		`EvictionRateLimit:` + valueToStringGenerated(this.EvictionRateLimit) + `,`,
		`EvictionTolerance:` + valueToStringGenerated(this.EvictionTolerance) + `,`,
		`RecommendationMarginFraction:` + valueToStringGenerated(this.RecommendationMarginFraction) + `,`,
		`UpdaterInterval:` + strings.Replace(fmt.Sprintf("%v", this.UpdaterInterval), "Duration", "v11.Duration", 1) + `,`,
		`RecommenderInterval:` + strings.Replace(fmt.Sprintf("%v", this.RecommenderInterval), "Duration", "v11.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Volume) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Volume{`,
		`Name:` + valueToStringGenerated(this.Name) + `,`,
		`Type:` + valueToStringGenerated(this.Type) + `,`,
		`VolumeSize:` + fmt.Sprintf("%v", this.VolumeSize) + `,`,
		`Encrypted:` + valueToStringGenerated(this.Encrypted) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VolumeType) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VolumeType{`,
		`Class:` + fmt.Sprintf("%v", this.Class) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Usable:` + valueToStringGenerated(this.Usable) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WatchCacheSizes) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForResources := "[]ResourceWatchCacheSize{"
	for _, f := range this.Resources {
		repeatedStringForResources += strings.Replace(strings.Replace(f.String(), "ResourceWatchCacheSize", "ResourceWatchCacheSize", 1), `&`, ``, 1) + ","
	}
	repeatedStringForResources += "}"
	s := strings.Join([]string{`&WatchCacheSizes{`,
		`Default:` + valueToStringGenerated(this.Default) + `,`,
		`Resources:` + repeatedStringForResources + `,`,
		`}`,
	}, "")
	return s
}
func (this *Worker) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTaints := "[]Taint{"
	for _, f := range this.Taints {
		repeatedStringForTaints += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForTaints += "}"
	repeatedStringForDataVolumes := "[]DataVolume{"
	for _, f := range this.DataVolumes {
		repeatedStringForDataVolumes += strings.Replace(strings.Replace(f.String(), "DataVolume", "DataVolume", 1), `&`, ``, 1) + ","
	}
	repeatedStringForDataVolumes += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	s := strings.Join([]string{`&Worker{`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
		`CRI:` + strings.Replace(this.CRI.String(), "CRI", "CRI", 1) + `,`,
		`Kubernetes:` + strings.Replace(this.Kubernetes.String(), "WorkerKubernetes", "WorkerKubernetes", 1) + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Machine:` + strings.Replace(strings.Replace(this.Machine.String(), "Machine", "Machine", 1), `&`, ``, 1) + `,`,
		`Maximum:` + fmt.Sprintf("%v", this.Maximum) + `,`,
		`Minimum:` + fmt.Sprintf("%v", this.Minimum) + `,`,
		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
		`ProviderConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProviderConfig), "RawExtension", "runtime.RawExtension", 1) + `,`,
		`Taints:` + repeatedStringForTaints + `,`,
		`Volume:` + strings.Replace(this.Volume.String(), "Volume", "Volume", 1) + `,`,
		`DataVolumes:` + repeatedStringForDataVolumes + `,`,
		`KubeletDataVolumeName:` + valueToStringGenerated(this.KubeletDataVolumeName) + `,`,
		`Zones:` + fmt.Sprintf("%v", this.Zones) + `,`,
		`SystemComponents:` + strings.Replace(this.SystemComponents.String(), "WorkerSystemComponents", "WorkerSystemComponents", 1) + `,`,
		`MachineControllerManagerSettings:` + strings.Replace(this.MachineControllerManagerSettings.String(), "MachineControllerManagerSettings", "MachineControllerManagerSettings", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WorkerKubernetes) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WorkerKubernetes{`,
		`Kubelet:` + strings.Replace(this.Kubelet.String(), "KubeletConfig", "KubeletConfig", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WorkerSystemComponents) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WorkerSystemComponents{`,
		`Allow:` + fmt.Sprintf("%v", this.Allow) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringGenerated(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Addon) 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 ErrIntOverflowGenerated
			}
			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: Addon: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Addon: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Addons) 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 ErrIntOverflowGenerated
			}
			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: Addons: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Addons: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesDashboard", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubernetesDashboard == nil {
				m.KubernetesDashboard = &KubernetesDashboard{}
			}
			if err := m.KubernetesDashboard.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NginxIngress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NginxIngress == nil {
				m.NginxIngress = &NginxIngress{}
			}
			if err := m.NginxIngress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AdmissionPlugin) 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 ErrIntOverflowGenerated
			}
			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: AdmissionPlugin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdmissionPlugin: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &runtime.RawExtension{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Alerting) 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 ErrIntOverflowGenerated
			}
			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: Alerting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Alerting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EmailReceivers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EmailReceivers = append(m.EmailReceivers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AuditConfig) 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 ErrIntOverflowGenerated
			}
			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: AuditConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AuditConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuditPolicy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AuditPolicy == nil {
				m.AuditPolicy = &AuditPolicy{}
			}
			if err := m.AuditPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AuditPolicy) 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 ErrIntOverflowGenerated
			}
			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: AuditPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AuditPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigMapRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConfigMapRef == nil {
				m.ConfigMapRef = &v1.ObjectReference{}
			}
			if err := m.ConfigMapRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowGenerated
			}
			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 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableMachineTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnavailableMachineTypes = append(m.UnavailableMachineTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableVolumeTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnavailableVolumeTypes = append(m.UnavailableVolumeTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupBucket) 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 ErrIntOverflowGenerated
			}
			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: BackupBucket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupBucket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupBucketList) 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 ErrIntOverflowGenerated
			}
			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: BackupBucketList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupBucketList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, BackupBucket{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupBucketProvider) 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 ErrIntOverflowGenerated
			}
			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: BackupBucketProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupBucketProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupBucketSpec) 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 ErrIntOverflowGenerated
			}
			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: BackupBucketSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupBucketSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Seed = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupBucketStatus) 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 ErrIntOverflowGenerated
			}
			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: BackupBucketStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupBucketStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderStatus == nil {
				m.ProviderStatus = &runtime.RawExtension{}
			}
			if err := m.ProviderStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOperation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastOperation == nil {
				m.LastOperation = &LastOperation{}
			}
			if err := m.LastOperation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastError == nil {
				m.LastError = &LastError{}
			}
			if err := m.LastError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GeneratedSecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GeneratedSecretRef == nil {
				m.GeneratedSecretRef = &v1.SecretReference{}
			}
			if err := m.GeneratedSecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupEntry) 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 ErrIntOverflowGenerated
			}
			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: BackupEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupEntryList) 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 ErrIntOverflowGenerated
			}
			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: BackupEntryList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupEntryList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, BackupEntry{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupEntrySpec) 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 ErrIntOverflowGenerated
			}
			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: BackupEntrySpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupEntrySpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BucketName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Seed = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BackupEntryStatus) 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 ErrIntOverflowGenerated
			}
			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: BackupEntryStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackupEntryStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOperation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastOperation == nil {
				m.LastOperation = &LastOperation{}
			}
			if err := m.LastOperation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastError == nil {
				m.LastError = &LastError{}
			}
			if err := m.LastError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CRI) 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 ErrIntOverflowGenerated
			}
			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: CRI: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CRI: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = CRIName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerRuntimes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerRuntimes = append(m.ContainerRuntimes, ContainerRuntime{})
			if err := m.ContainerRuntimes[len(m.ContainerRuntimes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudInfo) 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 ErrIntOverflowGenerated
			}
			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: CloudInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudProfile) 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 ErrIntOverflowGenerated
			}
			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: CloudProfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudProfile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudProfileList) 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 ErrIntOverflowGenerated
			}
			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: CloudProfileList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudProfileList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, CloudProfile{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloudProfileSpec) 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 ErrIntOverflowGenerated
			}
			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: CloudProfileSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloudProfileSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.CABundle = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubernetes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Kubernetes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineImages", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MachineImages = append(m.MachineImages, MachineImage{})
			if err := m.MachineImages[len(m.MachineImages)-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 MachineTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MachineTypes = append(m.MachineTypes, MachineType{})
			if err := m.MachineTypes[len(m.MachineTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeedSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SeedSelector == nil {
				m.SeedSelector = &SeedSelector{}
			}
			if err := m.SeedSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeTypes = append(m.VolumeTypes, VolumeType{})
			if err := m.VolumeTypes[len(m.VolumeTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClusterAutoscaler) 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 ErrIntOverflowGenerated
			}
			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: ClusterAutoscaler: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayAfterAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScaleDownDelayAfterAdd == nil {
				m.ScaleDownDelayAfterAdd = &v11.Duration{}
			}
			if err := m.ScaleDownDelayAfterAdd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayAfterDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScaleDownDelayAfterDelete == nil {
				m.ScaleDownDelayAfterDelete = &v11.Duration{}
			}
			if err := m.ScaleDownDelayAfterDelete.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownDelayAfterFailure", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScaleDownDelayAfterFailure == nil {
				m.ScaleDownDelayAfterFailure = &v11.Duration{}
			}
			if err := m.ScaleDownDelayAfterFailure.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownUnneededTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScaleDownUnneededTime == nil {
				m.ScaleDownUnneededTime = &v11.Duration{}
			}
			if err := m.ScaleDownUnneededTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDownUtilizationThreshold", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.ScaleDownUtilizationThreshold = &v2
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScanInterval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScanInterval == nil {
				m.ScanInterval = &v11.Duration{}
			}
			if err := m.ScanInterval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClusterInfo) 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 ErrIntOverflowGenerated
			}
			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: ClusterInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cloud", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Cloud.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubernetes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Kubernetes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Condition) 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 ErrIntOverflowGenerated
			}
			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: Condition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Condition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = ConditionType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Codes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Codes = append(m.Codes, ErrorCode(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerRuntime) 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 ErrIntOverflowGenerated
			}
			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: ContainerRuntime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerRuntime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerDeployment) 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 ErrIntOverflowGenerated
			}
			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: ControllerDeployment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := ControllerDeploymentPolicy(dAtA[iNdEx:postIndex])
			m.Policy = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeedSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SeedSelector == nil {
				m.SeedSelector = &v11.LabelSelector{}
			}
			if err := m.SeedSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerInstallation) 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 ErrIntOverflowGenerated
			}
			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: ControllerInstallation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerInstallation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerInstallationList) 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 ErrIntOverflowGenerated
			}
			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: ControllerInstallationList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerInstallationList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, ControllerInstallation{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerInstallationSpec) 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 ErrIntOverflowGenerated
			}
			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: ControllerInstallationSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerInstallationSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegistrationRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RegistrationRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeedRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SeedRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerInstallationStatus) 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 ErrIntOverflowGenerated
			}
			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: ControllerInstallationStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerInstallationStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, Condition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderStatus == nil {
				m.ProviderStatus = &runtime.RawExtension{}
			}
			if err := m.ProviderStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerRegistration) 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 ErrIntOverflowGenerated
			}
			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: ControllerRegistration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerRegistration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerRegistrationList) 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 ErrIntOverflowGenerated
			}
			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: ControllerRegistrationList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerRegistrationList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, ControllerRegistration{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerRegistrationSpec) 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 ErrIntOverflowGenerated
			}
			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: ControllerRegistrationSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerRegistrationSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, ControllerResource{})
			if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deployment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Deployment == nil {
				m.Deployment = &ControllerDeployment{}
			}
			if err := m.Deployment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControllerResource) 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 ErrIntOverflowGenerated
			}
			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: ControllerResource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControllerResource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GloballyEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.GloballyEnabled = &b
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReconcileTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReconcileTimeout == nil {
				m.ReconcileTimeout = &v11.Duration{}
			}
			if err := m.ReconcileTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Primary = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DNS) 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 ErrIntOverflowGenerated
			}
			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: DNS: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNS: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Domain = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Providers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Providers = append(m.Providers, DNSProvider{})
			if err := m.Providers[len(m.Providers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DNSIncludeExclude) 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 ErrIntOverflowGenerated
			}
			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: DNSIncludeExclude: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNSIncludeExclude: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Include", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Include = append(m.Include, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exclude", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Exclude = append(m.Exclude, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DNSProvider) 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 ErrIntOverflowGenerated
			}
			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: DNSProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNSProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domains", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Domains == nil {
				m.Domains = &DNSIncludeExclude{}
			}
			if err := m.Domains.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Primary = &b
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.SecretName = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Type = &s
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Zones == nil {
				m.Zones = &DNSIncludeExclude{}
			}
			if err := m.Zones.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataVolume) 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 ErrIntOverflowGenerated
			}
			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: DataVolume: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataVolume: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Type = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeSize = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encrypted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Encrypted = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Endpoint) 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 ErrIntOverflowGenerated
			}
			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: Endpoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Endpoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Purpose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Purpose = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExpirableVersion) 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 ErrIntOverflowGenerated
			}
			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: ExpirableVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExpirableVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationDate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExpirationDate == nil {
				m.ExpirationDate = &v11.Time{}
			}
			if err := m.ExpirationDate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Classification", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := VersionClassification(dAtA[iNdEx:postIndex])
			m.Classification = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Extension) 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 ErrIntOverflowGenerated
			}
			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: Extension: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Extension: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Disabled = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExtensionResourceState) 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 ErrIntOverflowGenerated
			}
			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: ExtensionResourceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExtensionResourceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Name = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Purpose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Purpose = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &runtime.RawExtension{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, v1beta1.NamedResourceReference{})
			if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Gardener) 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 ErrIntOverflowGenerated
			}
			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: Gardener: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Gardener: 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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GardenerResourceData) 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 ErrIntOverflowGenerated
			}
			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: GardenerResourceData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GardenerResourceData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Hibernation) 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 ErrIntOverflowGenerated
			}
			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: Hibernation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Hibernation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Enabled = &b
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schedules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schedules = append(m.Schedules, HibernationSchedule{})
			if err := m.Schedules[len(m.Schedules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HibernationSchedule) 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 ErrIntOverflowGenerated
			}
			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: HibernationSchedule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HibernationSchedule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Start = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.End = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Location = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HorizontalPodAutoscalerConfig) 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 ErrIntOverflowGenerated
			}
			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: HorizontalPodAutoscalerConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HorizontalPodAutoscalerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPUInitializationPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CPUInitializationPeriod == nil {
				m.CPUInitializationPeriod = &v11.Duration{}
			}
			if err := m.CPUInitializationPeriod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownscaleDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownscaleDelay == nil {
				m.DownscaleDelay = &v11.Duration{}
			}
			if err := m.DownscaleDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownscaleStabilization", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DownscaleStabilization == nil {
				m.DownscaleStabilization = &v11.Duration{}
			}
			if err := m.DownscaleStabilization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialReadinessDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InitialReadinessDelay == nil {
				m.InitialReadinessDelay = &v11.Duration{}
			}
			if err := m.InitialReadinessDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SyncPeriod == nil {
				m.SyncPeriod = &v11.Duration{}
			}
			if err := m.SyncPeriod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerance", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.Tolerance = &v2
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpscaleDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpscaleDelay == nil {
				m.UpscaleDelay = &v11.Duration{}
			}
			if err := m.UpscaleDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Ingress) 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 ErrIntOverflowGenerated
			}
			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: Ingress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Controller.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IngressController) 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 ErrIntOverflowGenerated
			}
			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: IngressController: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IngressController: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeAPIServerConfig) 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 ErrIntOverflowGenerated
			}
			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: KubeAPIServerConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeAPIServerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KubernetesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdmissionPlugins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AdmissionPlugins = append(m.AdmissionPlugins, AdmissionPlugin{})
			if err := m.AdmissionPlugins[len(m.AdmissionPlugins)-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 APIAudiences", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.APIAudiences = append(m.APIAudiences, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuditConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AuditConfig == nil {
				m.AuditConfig = &AuditConfig{}
			}
			if err := m.AuditConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableBasicAuthentication", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.EnableBasicAuthentication = &b
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OIDCConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OIDCConfig == nil {
				m.OIDCConfig = &OIDCConfig{}
			}
			if err := m.OIDCConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RuntimeConfig == nil {
				m.RuntimeConfig = make(map[string]bool)
			}
			var mapkey string
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RuntimeConfig[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ServiceAccountConfig == nil {
				m.ServiceAccountConfig = &ServiceAccountConfig{}
			}
			if err := m.ServiceAccountConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WatchCacheSizes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WatchCacheSizes == nil {
				m.WatchCacheSizes = &WatchCacheSizes{}
			}
			if err := m.WatchCacheSizes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Requests == nil {
				m.Requests = &KubeAPIServerRequests{}
			}
			if err := m.Requests.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeAPIServerRequests) 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 ErrIntOverflowGenerated
			}
			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: KubeAPIServerRequests: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeAPIServerRequests: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxNonMutatingInflight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MaxNonMutatingInflight = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxMutatingInflight", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MaxMutatingInflight = &v
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeControllerManagerConfig) 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 ErrIntOverflowGenerated
			}
			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: KubeControllerManagerConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeControllerManagerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KubernetesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HorizontalPodAutoscalerConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.HorizontalPodAutoscalerConfig == nil {
				m.HorizontalPodAutoscalerConfig = &HorizontalPodAutoscalerConfig{}
			}
			if err := m.HorizontalPodAutoscalerConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeCIDRMaskSize", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NodeCIDRMaskSize = &v
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodEvictionTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PodEvictionTimeout == nil {
				m.PodEvictionTimeout = &v11.Duration{}
			}
			if err := m.PodEvictionTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeProxyConfig) 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 ErrIntOverflowGenerated
			}
			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: KubeProxyConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeProxyConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KubernetesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := ProxyMode(dAtA[iNdEx:postIndex])
			m.Mode = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeSchedulerConfig) 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 ErrIntOverflowGenerated
			}
			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: KubeSchedulerConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeSchedulerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KubernetesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeMaxPDVols", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.KubeMaxPDVols = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeletConfig) 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 ErrIntOverflowGenerated
			}
			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: KubeletConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeletConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KubernetesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPUCFSQuota", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.CPUCFSQuota = &b
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPUManagerPolicy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.CPUManagerPolicy = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionHard", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictionHard == nil {
				m.EvictionHard = &KubeletConfigEviction{}
			}
			if err := m.EvictionHard.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionMaxPodGracePeriod", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EvictionMaxPodGracePeriod = &v
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionMinimumReclaim", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictionMinimumReclaim == nil {
				m.EvictionMinimumReclaim = &KubeletConfigEvictionMinimumReclaim{}
			}
			if err := m.EvictionMinimumReclaim.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionPressureTransitionPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictionPressureTransitionPeriod == nil {
				m.EvictionPressureTransitionPeriod = &v11.Duration{}
			}
			if err := m.EvictionPressureTransitionPeriod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionSoft", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictionSoft == nil {
				m.EvictionSoft = &KubeletConfigEviction{}
			}
			if err := m.EvictionSoft.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionSoftGracePeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictionSoftGracePeriod == nil {
				m.EvictionSoftGracePeriod = &KubeletConfigEvictionSoftGracePeriod{}
			}
			if err := m.EvictionSoftGracePeriod.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPods", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MaxPods = &v
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodPIDsLimit", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PodPIDsLimit = &v
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImagePullProgressDeadline", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImagePullProgressDeadline == nil {
				m.ImagePullProgressDeadline = &v11.Duration{}
			}
			if err := m.ImagePullProgressDeadline.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailSwapOn", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.FailSwapOn = &b
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeReserved", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubeReserved == nil {
				m.KubeReserved = &KubeletConfigReserved{}
			}
			if err := m.KubeReserved.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SystemReserved", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SystemReserved == nil {
				m.SystemReserved = &KubeletConfigReserved{}
			}
			if err := m.SystemReserved.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeletConfigEviction) 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 ErrIntOverflowGenerated
			}
			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: KubeletConfigEviction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeletConfigEviction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryAvailable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.MemoryAvailable = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSAvailable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ImageFSAvailable = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSInodesFree", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ImageFSInodesFree = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSAvailable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.NodeFSAvailable = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSInodesFree", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.NodeFSInodesFree = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeletConfigEvictionMinimumReclaim) 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 ErrIntOverflowGenerated
			}
			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: KubeletConfigEvictionMinimumReclaim: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeletConfigEvictionMinimumReclaim: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MemoryAvailable == nil {
				m.MemoryAvailable = &resource.Quantity{}
			}
			if err := m.MemoryAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageFSAvailable == nil {
				m.ImageFSAvailable = &resource.Quantity{}
			}
			if err := m.ImageFSAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSInodesFree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageFSInodesFree == nil {
				m.ImageFSInodesFree = &resource.Quantity{}
			}
			if err := m.ImageFSInodesFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeFSAvailable == nil {
				m.NodeFSAvailable = &resource.Quantity{}
			}
			if err := m.NodeFSAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSInodesFree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeFSInodesFree == nil {
				m.NodeFSInodesFree = &resource.Quantity{}
			}
			if err := m.NodeFSInodesFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeletConfigEvictionSoftGracePeriod) 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 ErrIntOverflowGenerated
			}
			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: KubeletConfigEvictionSoftGracePeriod: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeletConfigEvictionSoftGracePeriod: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MemoryAvailable == nil {
				m.MemoryAvailable = &v11.Duration{}
			}
			if err := m.MemoryAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageFSAvailable == nil {
				m.ImageFSAvailable = &v11.Duration{}
			}
			if err := m.ImageFSAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageFSInodesFree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageFSInodesFree == nil {
				m.ImageFSInodesFree = &v11.Duration{}
			}
			if err := m.ImageFSInodesFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSAvailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeFSAvailable == nil {
				m.NodeFSAvailable = &v11.Duration{}
			}
			if err := m.NodeFSAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeFSInodesFree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeFSInodesFree == nil {
				m.NodeFSInodesFree = &v11.Duration{}
			}
			if err := m.NodeFSInodesFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubeletConfigReserved) 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 ErrIntOverflowGenerated
			}
			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: KubeletConfigReserved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubeletConfigReserved: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPU", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CPU == nil {
				m.CPU = &resource.Quantity{}
			}
			if err := m.CPU.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Memory == nil {
				m.Memory = &resource.Quantity{}
			}
			if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EphemeralStorage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EphemeralStorage == nil {
				m.EphemeralStorage = &resource.Quantity{}
			}
			if err := m.EphemeralStorage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PID == nil {
				m.PID = &resource.Quantity{}
			}
			if err := m.PID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Kubernetes) 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 ErrIntOverflowGenerated
			}
			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: Kubernetes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Kubernetes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegedContainers", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.AllowPrivilegedContainers = &b
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterAutoscaler", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClusterAutoscaler == nil {
				m.ClusterAutoscaler = &ClusterAutoscaler{}
			}
			if err := m.ClusterAutoscaler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeAPIServer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubeAPIServer == nil {
				m.KubeAPIServer = &KubeAPIServerConfig{}
			}
			if err := m.KubeAPIServer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeControllerManager", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubeControllerManager == nil {
				m.KubeControllerManager = &KubeControllerManagerConfig{}
			}
			if err := m.KubeControllerManager.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeScheduler", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubeScheduler == nil {
				m.KubeScheduler = &KubeSchedulerConfig{}
			}
			if err := m.KubeScheduler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeProxy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KubeProxy == nil {
				m.KubeProxy = &KubeProxyConfig{}
			}
			if err := m.KubeProxy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubelet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kubelet == nil {
				m.Kubelet = &KubeletConfig{}
			}
			if err := m.Kubelet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VerticalPodAutoscaler", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VerticalPodAutoscaler == nil {
				m.VerticalPodAutoscaler = &VerticalPodAutoscaler{}
			}
			if err := m.VerticalPodAutoscaler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubernetesConfig) 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 ErrIntOverflowGenerated
			}
			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: KubernetesConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubernetesConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeatureGates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FeatureGates == nil {
				m.FeatureGates = make(map[string]bool)
			}
			var mapkey string
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.FeatureGates[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubernetesDashboard) 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 ErrIntOverflowGenerated
			}
			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: KubernetesDashboard: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubernetesDashboard: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthenticationMode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.AuthenticationMode = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addon", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Addon.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubernetesInfo) 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 ErrIntOverflowGenerated
			}
			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: KubernetesInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubernetesInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KubernetesSettings) 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 ErrIntOverflowGenerated
			}
			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: KubernetesSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KubernetesSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Versions = append(m.Versions, ExpirableVersion{})
			if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LastError) 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 ErrIntOverflowGenerated
			}
			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: LastError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.TaskID = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Codes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Codes = append(m.Codes, ErrorCode(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastUpdateTime == nil {
				m.LastUpdateTime = &v11.Time{}
			}
			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LastOperation) 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 ErrIntOverflowGenerated
			}
			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: LastOperation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastOperation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
			}
			m.Progress = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Progress |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = LastOperationState(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = LastOperationType(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Machine) 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 ErrIntOverflowGenerated
			}
			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: Machine: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Machine: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Image == nil {
				m.Image = &ShootMachineImage{}
			}
			if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MachineControllerManagerSettings) 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 ErrIntOverflowGenerated
			}
			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: MachineControllerManagerSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MachineControllerManagerSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineDrainTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MachineDrainTimeout == nil {
				m.MachineDrainTimeout = &v11.Duration{}
			}
			if err := m.MachineDrainTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineHealthTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MachineHealthTimeout == nil {
				m.MachineHealthTimeout = &v11.Duration{}
			}
			if err := m.MachineHealthTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineCreationTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MachineCreationTimeout == nil {
				m.MachineCreationTimeout = &v11.Duration{}
			}
			if err := m.MachineCreationTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxEvictRetries", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MaxEvictRetries = &v
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeConditions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeConditions = append(m.NodeConditions, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MachineImage) 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 ErrIntOverflowGenerated
			}
			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: MachineImage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MachineImage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Versions = append(m.Versions, MachineImageVersion{})
			if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MachineImageVersion) 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 ErrIntOverflowGenerated
			}
			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: MachineImageVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MachineImageVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirableVersion", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpirableVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRI", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CRI = append(m.CRI, CRI{})
			if err := m.CRI[len(m.CRI)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MachineType) 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 ErrIntOverflowGenerated
			}
			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: MachineType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MachineType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPU", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CPU.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GPU", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GPU.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Memory.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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Storage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Storage == nil {
				m.Storage = &MachineTypeStorage{}
			}
			if err := m.Storage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Usable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Usable = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MachineTypeStorage) 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 ErrIntOverflowGenerated
			}
			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: MachineTypeStorage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MachineTypeStorage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Class", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Class = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StorageSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Maintenance) 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 ErrIntOverflowGenerated
			}
			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: Maintenance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Maintenance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AutoUpdate == nil {
				m.AutoUpdate = &MaintenanceAutoUpdate{}
			}
			if err := m.AutoUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeWindow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimeWindow == nil {
				m.TimeWindow = &MaintenanceTimeWindow{}
			}
			if err := m.TimeWindow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfineSpecUpdateRollout", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.ConfineSpecUpdateRollout = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintenanceAutoUpdate) 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 ErrIntOverflowGenerated
			}
			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: MaintenanceAutoUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintenanceAutoUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesVersion", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.KubernetesVersion = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineImageVersion", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MachineImageVersion = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaintenanceTimeWindow) 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 ErrIntOverflowGenerated
			}
			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: MaintenanceTimeWindow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaintenanceTimeWindow: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Begin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Begin = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.End = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Monitoring) 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 ErrIntOverflowGenerated
			}
			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: Monitoring: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Monitoring: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Alerting", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Alerting == nil {
				m.Alerting = &Alerting{}
			}
			if err := m.Alerting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamedResourceReference) 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 ErrIntOverflowGenerated
			}
			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: NamedResourceReference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamedResourceReference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ResourceRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Networking) 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 ErrIntOverflowGenerated
			}
			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: Networking: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Networking: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Pods = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Nodes = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Services = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NginxIngress) 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 ErrIntOverflowGenerated
			}
			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: NginxIngress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NginxIngress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerSourceRanges", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoadBalancerSourceRanges = append(m.LoadBalancerSourceRanges, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Config[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalTrafficPolicy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := k8s_io_api_core_v1.ServiceExternalTrafficPolicyType(dAtA[iNdEx:postIndex])
			m.ExternalTrafficPolicy = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addon", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Addon.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OIDCConfig) 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 ErrIntOverflowGenerated
			}
			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: OIDCConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OIDCConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.CABundle = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientAuthentication", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientAuthentication == nil {
				m.ClientAuthentication = &OpenIDConnectClientAuthentication{}
			}
			if err := m.ClientAuthentication.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ClientID = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupsClaim", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GroupsClaim = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupsPrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GroupsPrefix = &s
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IssuerURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.IssuerURL = &s
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredClaims", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequiredClaims == nil {
				m.RequiredClaims = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequiredClaims[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningAlgs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SigningAlgs = append(m.SigningAlgs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsernameClaim", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.UsernameClaim = &s
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsernamePrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.UsernamePrefix = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OpenIDConnectClientAuthentication) 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 ErrIntOverflowGenerated
			}
			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: OpenIDConnectClientAuthentication: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenIDConnectClientAuthentication: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExtraConfig == nil {
				m.ExtraConfig = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ExtraConfig[mapkey] = mapvalue
			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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Secret = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Plant) 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 ErrIntOverflowGenerated
			}
			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: Plant: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Plant: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlantList) 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 ErrIntOverflowGenerated
			}
			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: PlantList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlantList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, Plant{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlantSpec) 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 ErrIntOverflowGenerated
			}
			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: PlantSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlantSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Endpoints = append(m.Endpoints, Endpoint{})
			if err := m.Endpoints[len(m.Endpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlantStatus) 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 ErrIntOverflowGenerated
			}
			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: PlantStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlantStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, Condition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ObservedGeneration = &v
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClusterInfo == nil {
				m.ClusterInfo = &ClusterInfo{}
			}
			if err := m.ClusterInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Project) 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 ErrIntOverflowGenerated
			}
			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: Project: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Project: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProjectList) 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 ErrIntOverflowGenerated
			}
			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: ProjectList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProjectList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, Project{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProjectMember) 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 ErrIntOverflowGenerated
			}
			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: ProjectMember: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProjectMember: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Subject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Role = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProjectSpec) 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 ErrIntOverflowGenerated
			}
			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: ProjectSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProjectSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedBy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedBy == nil {
				m.CreatedBy = &v13.Subject{}
			}
			if err := m.CreatedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Description = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Owner == nil {
				m.Owner = &v13.Subject{}
			}
			if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Purpose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Purpose = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Members = append(m.Members, ProjectMember{})
			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Namespace = &s
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tolerations == nil {
				m.Tolerations = &ProjectTolerations{}
			}
			if err := m.Tolerations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProjectStatus) 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 ErrIntOverflowGenerated
			}
			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: ProjectStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProjectStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Phase = ProjectPhase(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StaleSinceTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StaleSinceTimestamp == nil {
				m.StaleSinceTimestamp = &v11.Time{}
			}
			if err := m.StaleSinceTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StaleAutoDeleteTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StaleAutoDeleteTimestamp == nil {
				m.StaleAutoDeleteTimestamp = &v11.Time{}
			}
			if err := m.StaleAutoDeleteTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProjectTolerations) 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 ErrIntOverflowGenerated
			}
			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: ProjectTolerations: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProjectTolerations: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Defaults", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Defaults = append(m.Defaults, Toleration{})
			if err := m.Defaults[len(m.Defaults)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Whitelist", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Whitelist = append(m.Whitelist, Toleration{})
			if err := m.Whitelist[len(m.Whitelist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Provider) 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 ErrIntOverflowGenerated
			}
			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: Provider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Provider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlPlaneConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ControlPlaneConfig == nil {
				m.ControlPlaneConfig = &runtime.RawExtension{}
			}
			if err := m.ControlPlaneConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfrastructureConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InfrastructureConfig == nil {
				m.InfrastructureConfig = &runtime.RawExtension{}
			}
			if err := m.InfrastructureConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Workers = append(m.Workers, Worker{})
			if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Quota) 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 ErrIntOverflowGenerated
			}
			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: Quota: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Quota: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QuotaList) 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 ErrIntOverflowGenerated
			}
			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: QuotaList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuotaList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, Quota{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QuotaSpec) 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 ErrIntOverflowGenerated
			}
			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: QuotaSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuotaSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterLifetimeDays", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ClusterLifetimeDays = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metrics == nil {
				m.Metrics = make(k8s_io_api_core_v1.ResourceList)
			}
			var mapkey k8s_io_api_core_v1.ResourceName
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGenerated
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metrics[k8s_io_api_core_v1.ResourceName(mapkey)] = *mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Scope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowGenerated
			}
			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 Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zones", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceData) 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 ErrIntOverflowGenerated
			}
			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: ResourceData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrossVersionObjectReference", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CrossVersionObjectReference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceWatchCacheSize) 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 ErrIntOverflowGenerated
			}
			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: ResourceWatchCacheSize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceWatchCacheSize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.APIGroup = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resource = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CacheSize", wireType)
			}
			m.CacheSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CacheSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SecretBinding) 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 ErrIntOverflowGenerated
			}
			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: SecretBinding: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SecretBinding: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quotas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Quotas = append(m.Quotas, v1.ObjectReference{})
			if err := m.Quotas[len(m.Quotas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SecretBindingList) 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 ErrIntOverflowGenerated
			}
			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: SecretBindingList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SecretBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, SecretBinding{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Seed) 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 ErrIntOverflowGenerated
			}
			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: Seed: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Seed: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedBackup) 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 ErrIntOverflowGenerated
			}
			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: SeedBackup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedBackup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Provider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Region = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedDNS) 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 ErrIntOverflowGenerated
			}
			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: SeedDNS: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedDNS: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressDomain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.IngressDomain = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Provider == nil {
				m.Provider = &SeedDNSProvider{}
			}
			if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedDNSProvider) 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 ErrIntOverflowGenerated
			}
			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: SeedDNSProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedDNSProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domains", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Domains == nil {
				m.Domains = &DNSIncludeExclude{}
			}
			if err := m.Domains.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Zones == nil {
				m.Zones = &DNSIncludeExclude{}
			}
			if err := m.Zones.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedList) 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 ErrIntOverflowGenerated
			}
			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: SeedList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, Seed{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedNetworks) 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 ErrIntOverflowGenerated
			}
			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: SeedNetworks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedNetworks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Nodes = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pods = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Services = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShootDefaults", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ShootDefaults == nil {
				m.ShootDefaults = &ShootNetworks{}
			}
			if err := m.ShootDefaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedProvider) 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 ErrIntOverflowGenerated
			}
			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: SeedProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSelector) 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 ErrIntOverflowGenerated
			}
			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: SeedSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LabelSelector == nil {
				m.LabelSelector = &v11.LabelSelector{}
			}
			if err := m.LabelSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderTypes = append(m.ProviderTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettingExcessCapacityReservation) 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 ErrIntOverflowGenerated
			}
			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: SeedSettingExcessCapacityReservation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettingExcessCapacityReservation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettingLoadBalancerServices) 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 ErrIntOverflowGenerated
			}
			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: SeedSettingLoadBalancerServices: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettingLoadBalancerServices: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettingScheduling) 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 ErrIntOverflowGenerated
			}
			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: SeedSettingScheduling: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettingScheduling: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Visible", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Visible = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettingShootDNS) 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 ErrIntOverflowGenerated
			}
			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: SeedSettingShootDNS: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettingShootDNS: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettingVerticalPodAutoscaler) 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 ErrIntOverflowGenerated
			}
			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: SeedSettingVerticalPodAutoscaler: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettingVerticalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSettings) 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 ErrIntOverflowGenerated
			}
			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: SeedSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExcessCapacityReservation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExcessCapacityReservation == nil {
				m.ExcessCapacityReservation = &SeedSettingExcessCapacityReservation{}
			}
			if err := m.ExcessCapacityReservation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scheduling", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Scheduling == nil {
				m.Scheduling = &SeedSettingScheduling{}
			}
			if err := m.Scheduling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShootDNS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ShootDNS == nil {
				m.ShootDNS = &SeedSettingShootDNS{}
			}
			if err := m.ShootDNS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerServices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LoadBalancerServices == nil {
				m.LoadBalancerServices = &SeedSettingLoadBalancerServices{}
			}
			if err := m.LoadBalancerServices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VerticalPodAutoscaler", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VerticalPodAutoscaler == nil {
				m.VerticalPodAutoscaler = &SeedSettingVerticalPodAutoscaler{}
			}
			if err := m.VerticalPodAutoscaler.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedSpec) 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 ErrIntOverflowGenerated
			}
			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: SeedSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Backup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Backup == nil {
				m.Backup = &SeedBackup{}
			}
			if err := m.Backup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockCIDRs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockCIDRs = append(m.BlockCIDRs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DNS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DNS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Networks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SecretRef == nil {
				m.SecretRef = &v1.SecretReference{}
			}
			if err := m.SecretRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, SeedTaint{})
			if err := m.Taints[len(m.Taints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Volume", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Volume == nil {
				m.Volume = &SeedVolume{}
			}
			if err := m.Volume.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Settings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Settings == nil {
				m.Settings = &SeedSettings{}
			}
			if err := m.Settings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ingress == nil {
				m.Ingress = &Ingress{}
			}
			if err := m.Ingress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedStatus) 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 ErrIntOverflowGenerated
			}
			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: SeedStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, Condition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gardener", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Gardener == nil {
				m.Gardener = &Gardener{}
			}
			if err := m.Gardener.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.KubernetesVersion = &s
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdentity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ClusterIdentity = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedTaint) 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 ErrIntOverflowGenerated
			}
			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: SeedTaint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedTaint: 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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Value = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedVolume) 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 ErrIntOverflowGenerated
			}
			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: SeedVolume: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedVolume: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimumSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MinimumSize == nil {
				m.MinimumSize = &resource.Quantity{}
			}
			if err := m.MinimumSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Providers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Providers = append(m.Providers, SeedVolumeProvider{})
			if err := m.Providers[len(m.Providers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SeedVolumeProvider) 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 ErrIntOverflowGenerated
			}
			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: SeedVolumeProvider: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedVolumeProvider: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Purpose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Purpose = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceAccountConfig) 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 ErrIntOverflowGenerated
			}
			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: ServiceAccountConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAccountConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Issuer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Issuer = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningKeySecret", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SigningKeySecret == nil {
				m.SigningKeySecret = &v1.LocalObjectReference{}
			}
			if err := m.SigningKeySecret.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Shoot) 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 ErrIntOverflowGenerated
			}
			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: Shoot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Shoot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.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 ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootList) 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 ErrIntOverflowGenerated
			}
			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: ShootList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, Shoot{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootMachineImage) 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 ErrIntOverflowGenerated
			}
			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: ShootMachineImage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootMachineImage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Version = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootNetworks) 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 ErrIntOverflowGenerated
			}
			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: ShootNetworks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootNetworks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Pods = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Services = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootSpec) 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 ErrIntOverflowGenerated
			}
			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: ShootSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addons", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Addons == nil {
				m.Addons = &Addons{}
			}
			if err := m.Addons.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloudProfileName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CloudProfileName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DNS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DNS == nil {
				m.DNS = &DNS{}
			}
			if err := m.DNS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extensions = append(m.Extensions, Extension{})
			if err := m.Extensions[len(m.Extensions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hibernation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Hibernation == nil {
				m.Hibernation = &Hibernation{}
			}
			if err := m.Hibernation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubernetes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Kubernetes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Networking", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Networking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Maintenance", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Maintenance == nil {
				m.Maintenance = &Maintenance{}
			}
			if err := m.Maintenance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Monitoring", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Monitoring == nil {
				m.Monitoring = &Monitoring{}
			}
			if err := m.Monitoring.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Provider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Purpose", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := ShootPurpose(dAtA[iNdEx:postIndex])
			m.Purpose = &s
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Region = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretBindingName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecretBindingName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeedName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.SeedName = &s
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeedSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SeedSelector == nil {
				m.SeedSelector = &SeedSelector{}
			}
			if err := m.SeedSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, NamedResourceReference{})
			if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tolerations = append(m.Tolerations, Toleration{})
			if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootState) 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 ErrIntOverflowGenerated
			}
			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: ShootState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootStateList) 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 ErrIntOverflowGenerated
			}
			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: ShootStateList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootStateList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, ShootState{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootStateSpec) 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 ErrIntOverflowGenerated
			}
			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: ShootStateSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootStateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gardener", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Gardener = append(m.Gardener, GardenerResourceData{})
			if err := m.Gardener[len(m.Gardener)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extensions = append(m.Extensions, ExtensionResourceState{})
			if err := m.Extensions[len(m.Extensions)-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 Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, ResourceData{})
			if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShootStatus) 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 ErrIntOverflowGenerated
			}
			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: ShootStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShootStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, Condition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constraints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Constraints = append(m.Constraints, Condition{})
			if err := m.Constraints[len(m.Constraints)-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 Gardener", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Gardener.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsHibernated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsHibernated = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOperation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastOperation == nil {
				m.LastOperation = &LastOperation{}
			}
			if err := m.LastOperation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastError == nil {
				m.LastError = &LastError{}
			}
			if err := m.LastError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastErrors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastErrors = append(m.LastErrors, LastError{})
			if err := m.LastErrors[len(m.LastErrors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryCycleStartTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RetryCycleStartTime == nil {
				m.RetryCycleStartTime = &v11.Time{}
			}
			if err := m.RetryCycleStartTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Seed = &s
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TechnicalID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TechnicalID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdentity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ClusterIdentity = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Toleration) 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 ErrIntOverflowGenerated
			}
			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: Toleration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Toleration: 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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			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 Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Value = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerticalPodAutoscaler) 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 ErrIntOverflowGenerated
			}
			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: VerticalPodAutoscaler: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerticalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictAfterOOMThreshold", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EvictAfterOOMThreshold == nil {
				m.EvictAfterOOMThreshold = &v11.Duration{}
			}
			if err := m.EvictAfterOOMThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionRateBurst", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EvictionRateBurst = &v
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionRateLimit", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.EvictionRateLimit = &v2
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictionTolerance", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.EvictionTolerance = &v2
		case 6:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecommendationMarginFraction", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.RecommendationMarginFraction = &v2
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdaterInterval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdaterInterval == nil {
				m.UpdaterInterval = &v11.Duration{}
			}
			if err := m.UpdaterInterval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecommenderInterval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RecommenderInterval == nil {
				m.RecommenderInterval = &v11.Duration{}
			}
			if err := m.RecommenderInterval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Volume) 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 ErrIntOverflowGenerated
			}
			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: Volume: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Volume: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Name = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Type = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeSize = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encrypted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Encrypted = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VolumeType) 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 ErrIntOverflowGenerated
			}
			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: VolumeType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VolumeType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Class", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Class = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Usable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Usable = &b
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WatchCacheSizes) 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 ErrIntOverflowGenerated
			}
			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: WatchCacheSizes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WatchCacheSizes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Default = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Resources = append(m.Resources, ResourceWatchCacheSize{})
			if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Worker) 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 ErrIntOverflowGenerated
			}
			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: Worker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Worker: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.CABundle = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRI", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CRI == nil {
				m.CRI = &CRI{}
			}
			if err := m.CRI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubernetes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kubernetes == nil {
				m.Kubernetes = &WorkerKubernetes{}
			}
			if err := m.Kubernetes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					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 ErrIntOverflowGenerated
						}
						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 ErrInvalidLengthGenerated
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGenerated
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Machine", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Machine.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Maximum", wireType)
			}
			m.Maximum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Maximum |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Minimum", wireType)
			}
			m.Minimum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Minimum |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxSurge == nil {
				m.MaxSurge = &intstr.IntOrString{}
			}
			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxUnavailable == nil {
				m.MaxUnavailable = &intstr.IntOrString{}
			}
			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConfig == nil {
				m.ProviderConfig = &runtime.RawExtension{}
			}
			if err := m.ProviderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, v1.Taint{})
			if err := m.Taints[len(m.Taints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Volume", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Volume == nil {
				m.Volume = &Volume{}
			}
			if err := m.Volume.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataVolumes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataVolumes = append(m.DataVolumes, DataVolume{})
			if err := m.DataVolumes[len(m.DataVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubeletDataVolumeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.KubeletDataVolumeName = &s
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zones", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				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 ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Zones = append(m.Zones, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SystemComponents", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SystemComponents == nil {
				m.SystemComponents = &WorkerSystemComponents{}
			}
			if err := m.SystemComponents.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineControllerManagerSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MachineControllerManagerSettings == nil {
				m.MachineControllerManagerSettings = &MachineControllerManagerSettings{}
			}
			if err := m.MachineControllerManagerSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkerKubernetes) 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 ErrIntOverflowGenerated
			}
			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: WorkerKubernetes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkerKubernetes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubelet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kubelet == nil {
				m.Kubelet = &KubeletConfig{}
			}
			if err := m.Kubelet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkerSystemComponents) 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 ErrIntOverflowGenerated
			}
			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: WorkerSystemComponents: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkerSystemComponents: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Allow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Allow = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenerated(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenerated
			}
			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, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				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, ErrInvalidLengthGenerated
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenerated
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenerated
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
)
